笔记：2016-06-02

JAVA

判断那个方法是重载

void show(int w, double c, char b){}

void show(int x, char y, double z){} true

void show(int a, double c, char b){} false

void show(int a, char b){} true

void show(double c){} true

double show(int x, char y, double z){} true

 

1. 数组的定义

格式1：

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

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

格式2：

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

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

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

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;

              }

       }

}

}

冒泡排序

/*

冒泡排序。

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

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

*/

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;

                           }

                  }

          }

}

折半查找(二分法)

案例四：

/*

为了提高查找效率，可使用折半查找的方式，注意：这种查找只对有序的数组有效。

这种方式也成为二分查找法。

*/

public static int halfSeach(int[] arr,int key)

{

            int min,mid,max;

            min = 0;

             max = arr.length-1;

             mid = (max+min)/2;

             while(arr[mid]!=key)

             {

                           if(key>arr[mid])

                                     min = mid + 1;

                           else if(key<arr[mid])

                                     max = mid - 1;

                            if(min>max)

                                     return -1;

                           mid = (max+min)/2;

                 }

                return mid;

}

 

数组翻转

/*

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

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

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

*/

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;

}

 

 

为什么a.length = 3, a[0].length = 4?

数组的初始化：

静态初始化:

int [][] a = new int[][]{ {12,34,45,89},{34,56,78,10},{1,3,6,4} };

动态初始化：

 

 

 

 

 

// $()函数的另外一个作用：动态创建元素

var $spanNode = $(“<span>我是一个span元素</span>”);