黑马程序员_Java基础（下）

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

 

函数

定义：函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法

格式：

   修饰符  返回值类型  函数名(参数类型  形式参数1，参数类型  形式参数2)

  {

  执行语句;

  return 返回值;

  }

  返回值类型：函数运行后的结果的数据类型。

  参数类型：是形式参数的数据类型。

  形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

  实际参数：传递给形式参数的具体数值。

  return：用于结束函数。

  返回值：该值会返回给调用者

 

特点：定义函数可以将功能代码块进行封装，代码复用性提高，提高代码阅读性

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

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

使用注意事项：函数中只能调用函数，不可以在函数内部定义函数；定义函数时，函数的结果应该返回给调用者，交由调用者处理

 

函数的使用：函数其实就是一个功能，定义函数就是实现功能，通过两个明确来完成

       1.明确该功能的运算完的结果，其实是在明确这个函数的返回值类型；2.在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个函数的参数列表(参数类型&参数个数)

函数的重载：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了

       重载与返回值类型无关，只看参数列表

       函数的功能一样，仅仅是参与运算的未知内容不同时，在调用时，虚拟机通过参数列表的不同来区分同名函数。

       示例：  int minus（int a，int b）{return a-b} //返回两个数的减

                    int minus（double a，double b，double c）return{ a-b-c} //返回三个数的减

 

数组

定义：同一种数类型的集合容器。给每一个里面元素从0开始编号，可以通过index对数组中的元素进行操作

两种格式：1.元素类型 [] 数组名 = new 元素类型[元素个数或数组长度] ;   int[] arr = new int[4];

                  2.元素类型[] 数组名 = new 元素类型[]{元素1，元素2，……};    int[] arr = new int[]{1,2,3,4,5,6};

                     元素类型[] 变量名 = {元素1，元素2...};    int[] arr = {1,2,3,4,5};

内存结构分为5各部分：栈内存、堆内存、方法区、本地方法区、寄存器

       栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量)；

                 只要数据运算完成所在的区域结束，该数据就会被释放。

      堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。

               1：每一个实体都有内存首地址值

               2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样

               3：垃圾回收机制

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

                      二维数组中有3个一维数组

                      每一个一维数组中有2个元素

                      一维数组的名称分别为arr[0], arr[1], arr[2]

                      给第一个一维数组1脚标位赋值为3写法是：arr[0][1] = 3

                   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,4,2},{3,7},{9,6}

                        每一个一维数组中具体元素也都已初始化

                       arr[0] = {3,4,2};  arr[1] = {3,7}; arr[2] = {9,6};

for循环求数组所有元素的和：

class GetSum {public static void main(String[] args) {// TODO Auto-generated method stubint[] arr={1,2,4,8,9} ; //int[]arr=new int[]{1,2,4,8,9};int sum = 0;for(int i=0;i<arr.length;i++) {sum+=arr[i];  }System.out.println("sum="+sum);}}

数组排序

 选择排序：

               思想：对比数组中前一个元素跟后一个元素的大小，如果后面的元素比前面的元素小则用一个变量temp来记住他的位置，接着第二次比较，前面“后一个元素”现变成了“前一个元素”，继续跟他的“后一个元素”进行比较如果后面的元素比他要小则用变量temp记住它在数组中的位置(下标)，等到循环结束的时候，我们应该找到了最小的那个数的下标了，然后进行判断，如果这个元素的下标不是第一个元素的下标，就让第一个元素跟他交换一下值，这样就找到整个数组中最小的数了。然后找到数组中第二小的数，让他跟数组中第二个元素交换一下值，以此类推。内循环结束一次，最值出现在头脚标位置

               核心代码：

                         public static void SelectSort(int[] arr)

                           {

                              for (int i = 0; i < arr.length - 1; i++)//由于最后只剩自身了，所以不需要和自身比，比较次数arr.length-1

                                   {

                                       for (int j = i+1; j < arr.length; j++)//j=i+1保证比较的是前后比较

                                           {

                                               if(a[i]>a[j])//假如数组i角标所在的值大于j的值，就把i的值赋值给临存变量temp，两者再进行位置置换。

                                                  {

                                                       int temp = a[i];//定义一个临时变量记住该值，以便交换位置

                                                       a[i] = a[j];

                                                       a[j] = temp;

                                                   }

                                            }

                                  }

                         }

 

插入排序：

            思想：比较相邻的元素。如果第一个比第二个大，就交换他们两个

                       对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数

                       针对所有的元素重复以上的步骤，除了最后一个

                       持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较，、

                       第一圈比较晚后最值出现在最后位置

            核心代码：

                      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;

                                         }
                                    }
                                }
                         }

排序算法的特点：

   排序法   

平均时间

最差情形

  稳定度  

  额外空间   

  备注   

冒泡

O(n²)

O(n²)

稳定

O(1)

n小时较好

交换

O(n²)

O(n²)

不稳定

O(1)

n小时较好

选择

O(n²)

O(n²)

不稳定

O(1)

n小时较好

插入

O(n²)

O(n²)

稳定

O(1)

  大部分已排序时较好   

基数

   O(log_RB)    

O(log_RB)

稳定

O(n)

B是真数(0-9)，

R是基数(个十百)

Shell

O(nlogn)

  O(n^s) 1<s<2   

不稳定

O(1)

s是所选分组

快速

O(nlogn)

O(n²)

不稳定

O(nlogn)

n大时较好

归并

O(nlogn)

O(nlogn)

稳定

O(1)

n大时较好

堆

O(nlogn)

O(nlogn)

不稳定

O(1)

n大时较好 

 

折半查找：前提是数组是有序的，提高效率

    public static inthalfSeach(int[] arr,int key){

        int min,max,mid;

        min = 0;

        max =arr.length-1;

        mid =(max+min)>>1;//(max+min)/2;

        while(arr[mid]!=key){

            if(key>arr[mid]){

                min = mid+ 1;

            }

            elseif(key<arr[mid])

                max = mid- 1;

            if(max<min)

                return -1;

            mid =(max+min)>>1;

        }

        return mid;

    }