Java(2012/1/30)

 一、 包装类（Wrapper Class）:针对于原生数据类型的包装，所有包装类（8个）都位于java.lang包下，分别是：Byte，Short，Integer，Long，Float，Double，Character，Boolean。他们的使用方式都一样，可以实现原生数据类型与包装数据类型的双向转换。

 

*栈内存和堆内存之分

当一个方法执行时，每个方法都会建立自己的内存栈，在这个方法内定义的变量都会逐个放入这块栈内存里，随着方法的执行结束，这个方法的内存栈也随着销毁。因此所有方法中定义的变量都放在栈内存中；当我们在程序中创建一个对象时，这个对象将被保存到运行时的数据区中，以便反复利用（因为对象的创建成本通常比较大），这个运行时的数据区就是堆内存。堆内存中的对象不会随方法的结束而销毁，即使方法结束后，这个对象还可能被另一个引用变量所引用，则这个对象依然不会被销毁。只有当一个对象没有任何引用变量去引用它时，系统的垃圾回收机制才会在合适的时候去回收它。

 

二、Java 数组（Array）：相同类型数据的集合就叫做数组；数组也是一种数据类型，它本身是一种引用类型（例如int是一种原生类型，int[]是一种引用类型）；

           //数组也是一种对象

           //Java的数组既可以存储原生类型数据（存储原生类型数据的值），也可以存储引用类型数据(存储引用类型数据的是引用，而不是对象)，只要类型相同就行

       1）数组定义：type[] variableName      //推荐用这一种

                                 type variableName[] 

                       如： int[] a           //定义一个整型数组a

       2）数组初始化方式： //定义好数组如果没有为其初始化（对于长度大的数组可用循环语句为其初始化），则由系统自动分配

             a）int[] a = new int[4];

                   a[0] = 1;

                   a[1] = 2;

                   a[2] = 3;

                   a[3] = 4;

              b)int[] a = new int[]{1,2,3,4};

              c)int[] a = {1,2,3,4};

       3）Java中每个数组都有一个length属性（public final int），表示数组的长度；一旦数组的初始化完成，即数组对象创建完成后，数组的在内存中所占的空间就固定下来了，即数组的长度一旦确定就不能被改变。

       4）int[] a = new int[10]，其中a是一个引用 ，它指向了生成数组对象的首地址，数组中每个元素都是int类型，其中仅存放数据值本身。

             

         5）Person为自定义的一个类                                                        

            Person[] p = new Person[4];

            p[0] = new Person(10);                                                                    

            p[1] = new Person(20);

            p[2] = new Person(30);

       6）Java中的foreach方法如下：

                          for（type variableName : array | collection）

                          {

                                       //variableName自动迭代访问每个元素

                          }

 

       7）二维数组：二维数组是一种平面的二维结构，本质上是数组的数组。二维数组的定义方式：type[][] variableName = new type[number][number];

 

           int[][] a = new int[2][3];

           int b = 2;

           for(int i = 0; i < a.length; i++)   //行控制
           {
   
                     for(int j = 0; j < a[i].length; j++)     //列控制
                     {
                              a[i][j] = b;
                              b += 2;
                     }

            }

            for(int i = 0; i < a.length; i++)    //按顺序打印二维数组的所有元素
            {
                      for(int integer : a[i])
                     {
                              System.out.println(integer);
                     }
            }

        8)数组的拷贝：System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length);

 

三、Arrays类：位于java.util.Arrays

 

四、数组的排序

       1）冒泡排序     

              //冒泡排序法，升序排序
              public static void bubblingSort(int[] array)
              {
                           for(int i = 0; i < array.length-1; i++)
                           { 
                                      for(int j = 0; j < array.length - i - 1; j++)
                                      {
                                                    if(array[j] > array[j + 1])
                                                    {
                                                               int temp = array[j];
                                                               array[j] = array[j + 1];
                                                               array[j + 1] = temp;

                                                            /*array[j] = array[j] + array[j + 1];

                                                               array[j + 1] = array[j] - array[j + 1];

                                                               array[j] = array[j] - array[j + 1];

                                                            */
                                                      }
                                         }
                             }
                }

 

               //冒泡排序法，降序排序
               public static void bubblingSort(int[] array)
              {
                           for(int i = 0; i < array.length-1; i++)
                           { 
                                       for(int j = array.length - 1; j > i ; j--)
                                       {
                                                   if(array[j] > array[j - 1])
                                                   {
                                                            int temp = array[j];
                                                            array[j] = array[j - 1];
                                                            array[j - 1] = temp;
                                                    }
                                       }
                            }

               }

           2)交换排序

            //交换排序法，升序排序
            public static void swapSort(int[] array)
            {
                        for(int i = 0; i < array.length-1; i++)
                        {
                                 for(int j = i; j < array.length; j++)
                                 {
                                           if(array[i] > array[j])
                                           {
                                                   int temp = array[i];
                                                   array[i] = array[j];
                                                   array[j] = temp;
                                           }
                                  }
                        }
            }

           3）快速排序
              //快速排序法，升序排序
             public static void quickSort(int[] array)
             {
                    int i = 0;
                    int j = array.length - 1;
                    int key = array[0];
  
                    while(i != j )
                    {
                            while(array[j] > key)
                            {
                                    j--;  
                            }
                            int temp = key;
                            key = array[j];
                            array[j] = temp;

                            while(array[i] < key)
                            {
                                   i++;
                            }
                           temp = key;
                           key = array[i];
                           array[i] = temp;

                   }
             }

 

五、数组的查找

       1）二分查找（Binary Search）：待查找的数组必须有序（升序或降序）

           public static int binarySearch(int[] array,int dest)
           {
                       int mid;
                       int low = 0;
                       int high = array.length - 1;
    
                       while(low <= high)
                       {
                                 mid = (low + high)/2;
                                 if(dest == array[mid])
                                 {
                                             return (mid+1);
                                 }
                                else if(dest < array[mid])
                                {
                                             high = mid - 1;
                                }
                                else   

                                {

                                             low = mid + 1;

                                }

                        }
  
                        return -1;
            }

六、Math.random()生成介于两个值之间的随机数

         (数据类型)(最小值+Math.random()*(最大值-最小值+1))

         如生成介于10与50之间的随机数（包含10和50）：

          (int)(Math.random()*41+10)

         例子：随机生成50个数字（整数），每个数字的范围是[10,50]，统计每个数字出现的次数以及出现次数最多的数字与它的个数，最后将每个数字及其出现次数打印出来，如果某个数字出现次数为0，则不需要打印它，打印时按照数字的升序排列。

          

                 int[] count = new int[41];       //依次存放10到50中随机数出现的个数

                 for(int i = 0; i < 50; i++)
                 {
                             int number = (int)(Math.random() * 41 + 10);
                             count[number - 10]++;
                 }
  
                 for(int i = 0; i < count.length; i++)
                 {
                            if(count[i] != 0)
                            {          
                                         System.out.println((i + 10) + "出现次数为：" + count[i]);
                            }
                 }

                 int max = count[0];
  
                 for(int i = 0; i < count.length; i++)
                 {
                          if(max < count[i])
                          {
                                        max = count[i];
                          }
                 }
                System.out.println("----------------------");
                System.out.println("出现最大次数为：" + max);

                for(int i = 0; i < count.length; i++)
                {
                             if(max == count[i])
                             {
                                         System.out.println("数值为：" + (i+10));
                             }
                 }