java基础--笔记5



变量是用来存放常量值。

问题：数据少的时候，可以定义单独的变量空间存储起来。

          可是数据一旦多了，再使用这种变量的方式，很不方便。

数组：把 同一类型的数据组合一起的集合。

如何定义数组：

     定义数组需要通过关键字  new

怎么使用数组呢

     数组有个特性：

1,数组所有的空间都拥有自己的角标（下标，索引），这时可以通过数组+角标的方式访问数组的每一个空间。

2,数组定义完成后，如果没有给数组空间中赋值，数组空间中有默认的初始化值。

int类型的数组默认初始值为0

double  0.0

String ""

char '\u0000'

boolean false

使用格式：

int []  arr = new int[5];

arr[0]

java的内存分布

64M  java吧内存划分了五部分

1，栈内存      运行方法的，所有定义的局部变量，都在这片内存 区域中。（局部变量：定义在方法中，方法的参数中，for循环中的变量）

2，堆内存     所有对象都在这里存放着，用过new关键字创建出来的东西都存放在这里。当堆内存中的对象（通过new关键字创建出来的）没有任何的引用指向它的时候，这个对象就变成了垃圾，等待垃圾回收机制的清理。

3，方法区     所有的class文件，以及所有的静态的东西，还有常量池等。

4，本地方法区     主要存放本地方法

5，寄存器     给cpu使用

数组的内存图解

数组使用过程中常见的2个小问题：

1、 ArrayIndexOutOfBoundsException  异常    数组角标越界异常
          发生此问题的原因是：访问的到数组中不存在的角标。
    
     2、 NullPointerException 空指针异常
          当一个引用不再指向任何对象时，仍然在使用这个引用，去操作某个对象。这时就会发生空指针异常

如果在定义数组时，就明确了数组中存放的数据，就这样定义

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

     简写为如下格式：
     int[] arr = {1,2,3,4,5};

在数组实例中有个属性length中记录着当前这个数组的长度。

数组的应用：

遍历：把数组的每个空间都访问一遍。

练习：

需求：将数组中的元素，变成字符串显示在屏幕中。

class ArrayDemo3
{
     public static void main(String[] args)
     {
          int[] arr ={1,2,3,4,5,45,567,78,9};
          //数组的角标是从0开始，并且有规律的在变化,使用循环来提供数组的角标
          System.out.println(arr.length);
          for(int i=0;i<arr.length;i++)
          {
               if( i != arr.length-1 )
               {
                    System.out.print(arr[i]+",");
               }
               else
               {
                    System.out.println(arr[i]);
               }
          }
     }
}

---

     /*
     需求：求数组中的最大值
     思路：
          1、需要一个功能，这个功能就是用来求数组的最大值。
          2、要定义功能，就必须有两个明确：
               这个功能需要接受参数，接受的参数就是数组
              有返回值，返回的就是数组的中的最大值。
          3、方法定义好了，具体怎么求数组最大值呢？
               先临时假设数组中的一个值为最大值。
          4、需要取出数组中的每一个数和假设的这个最大值作比较，如果取出的这个数比假设的最大值大，
               就要把当前出去来的这个数替换假设的那个最大值。
     步骤：
     1、定义功能，求数组最大值
     2、假设某数组中的某一个数为最大值
     3、遍历数组，取出每一个数
     4、判断取出的这个数和假设那个数谁大。
     5、替换最大值
     6、返回最大值
*/
class ArrayTest2
{
     public static void main(String[] args)
     {
          // 定义一个数组
          int [] arr = {1,3,5,7,9};
          int max = getMax(arr);
          System.out.println("max="+max);
     }
     // 定义一个功能，求数组最大值
     /*
     public static int getMax(int [] arr)
     {
          int max = arr[0];
          for (int i=0; i<arr.length; i++)
          {
               if (arr[i] > max)
               {
                    max = arr[i];
               }
          }
          return max ;
     }
          */
          // 定义一个功能，求数组最大值
     public static int getMax(int [] arr)
     {
          int index = 0 ;
          for (int i = 1; i< arr.length; i++)
          {
               if (arr[i] > arr[index])
               {
                    index = i ;
               }
          }
          return arr[index] ;
     }
    
}
/*
初次写代码时，返回值写成了return index ，最后运行结果为4。才发现返回的是角标，
所以，一定要注意返回的是数组的最大值，也就是角标对应的那个。
*/

---

 需求：求数组中所有元素的和值？
        思路：
          1、要定义一个功能，用于求数组中所有元素和
               明确1：有没有参数呢？有，就是数组
               明确2：有没有返回值？有，和值
          2、要求所有元素的和值，需要一个存放所有和值的空间，并且这个空间的起始值为0
          3、遍历数组，取出数组中的每一个元素，把每一个元素加到和值空间去
          4、返回和值
    

*/
class ArrayTest3
{
     public static void main(String[] args)
     {
          int [] arr ={1,3,5,7,9};
          int sum = getSum(arr) ;
          System.out.println("sum="+sum);
     }
     // 定义一个功能求数组所以元素的和
     public static int getSum(int [] arr)
     {
          int sum = 0 ;
          for (int i = 0; i<arr.length; i++)  // i为数组中元素角标
          {
               sum = sum + arr[i] ;   //注意是sum=sum+arr[i] 而不是sum=sum+i
          }
          return sum ;
     }
}

---

/*
     需求：数组转置（反转）
     原始数组：{8,1,3,6,2,5,7}    
     结果数组：{7,5,2,6,3,1,8}
     思路：为了实现数组的反转，就是将数组的最前和最后以及别的相互对应的元素互换，
               可以定义一个功能进行元素互换，在互换时，可以考虑为角标的移动，最前
               那个角标和最后那个角标的移动，最前那个角标start每换一次向后移动一下，最后
               那个角标end每换一次向左移动一下，当start>=end是，交换结束。


*/

class ArrayTest4
{
     public static void main(String[] args)
     {
          int [] arr = {1,3,5,7,9};
          printArray(arr);
          reverse(arr);
          printArray(arr);
     }
     // 定义功能实现数组反转
     public static void reverse(int [] arr)
     {
          for (int start = 0 ,  end = arr.length-1 ; start < end ; start++ , end--)
          {
               int temp = arr[start] ;
               arr[start] = arr[end ];
               arr[end] = temp ;
          }
    
     }
     // 定义功能用于打印数组
     public static void printArray(int [] arr)
     {
          for (int i = 0 ; i < arr.length; i++)
          {
               if (i != arr.length-1)
               {
                    System.out.print(arr[i]+",");
               }
               else
               {
                    System.out.println(arr[i]);
               }
          }
     }
}

---

需求：选择排序
思路：定义一个功能个数组排序。
       选择排序的思想是第一个数据和它后面的数据一个个比较，要是第一个数据小于后面的数据，就交换
       ，第一轮比较完，得到的是数组的第一个元素最小。然后第二个元素和它后面的元素比较。。。
       这样循环比较，就要用到嵌套循环，外循环提供起始的位置，内循环提供外循环提供的数据后面的所
       有数据。
*/

class ArrayTest5
{
     public static void main(String[] args)
     {
          int [] arr = {1,9,7,8,4,6,5};
          printArray(arr);
          sortArray(arr);
          printArray(arr);
     }
     //定义功能，给数组排序---选择排序
     public static void sortArray(int [] arr)
     {
          // 外循环提供起始值位置的角标
          for (int i = 0; i<arr.length-1; i++)
          {
               //  内循环提供外循环提供的起始值后面的所以数据的角标
               for (int j = i+1; j<arr.length; j++)
               {
                    if (arr[i] > arr[j])
                    {
                         int temp = arr[i];
                         arr[i] = arr[j];
                         arr[j] = temp ;
                    }
               }
          }
     }
          // 定义功能用于打印数组
     public static void printArray(int [] arr)
     {
          for (int i = 0 ; i < arr.length; i++)
          {
               if (i != arr.length-1)
               {
                    System.out.print(arr[i]+",");
               }
               else
               {
                    System.out.println(arr[i]);
               }
          }
     }
}

---

查表法：
         拿到具体的数值，这个数值和数组的角标有一定关系。通过这个关系，就能到数组角标。再通过角标就可以取到数组中的数据。

数组空间中可以存放具体的数据。当调用者传递一个具体的数据进来时，使用这个数据从数组中去找对应的星期。


     String[] weeks = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};  5 - 1
                         0         1        2         3        4        5       6

     只要数组中存放的数据和角标有一定的对应关系，这时就可以把数组当作一张表。


*/

class ArrayDemo8
{
     public static void main(String[] args)
     {
          int day = 10;
          String week = getWeek(day);
          System.out.println(day + "对应星期为：" + week);
          System.out.println("over");
     }
     /*
       

---

   需求：采用查表法，完成数据和星期的对应关系

     */
     //定义功能，根据传递进来的数据，返回对应星期。
     public static String getWeek( int day )
     {
          if( day < 1 || day > 7 )
          {
               throw new RuntimeException("没有这个星期");
//               return "没有这个星期";
          }
          //建立星期的那个数组，即表
          String[] weeks = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
          return weeks[day];
     }

}

class ArrayDemo10
{
     public static void main(String[] args)
     {
         
          System.out.println(toHex(0));
          System.out.println(toOctal(0));
          System.out.println(toBinary(0));

          System.out.println(Integer.toHexString(0));
          System.out.println(Integer.toOctalString(0));
          System.out.println(Integer.toBinaryString(0));
     }
     //定义功能完成十进制-->十六进制
     public static String toHex(int num)
     {
          return "0x"+trans( num,15,4 );
     }
     //定义功能完成十进制-->八进制
     public static String toOctal(int num)
     {
          return "0"+trans( num,7,3 );
     }
     //定义功能完成十进制-->二进制
     public static String toBinary(int num)
     {
          return "0b"+trans( num,1,1 );
     }

     public static String trans( int num , int num2 ,int offset )
     {
          char[] chs = {'0','1','2','3',
                         '4','5','6','7',
                         '8','9','A','B',
                         'C','D','E','F'};
          //定义临时数组存放每次查表得到的字符
          char[] ch = new char[32];
          //用于提供临时数组的角标，同时可以记录临时数组中存放的数据具体位置
          int pos = 0;
          while( num!=0 )
          {
               int temp = num & num2;
               //System.out.println(chs[temp]);
               //把查表获得字符存放到临时数组中
               ch[pos] = chs[temp];
               pos++;
               num = num >>> offset;
          }
          String str = "";
          for(int i=pos-1 ;i>=0 ;i--)
          {
               str = str + ch[i];
          }
          return str;


          //System.out.println(pos);
          /*
          //打印临时数组中存放那些字符
          for( int i = pos-1 ; i>=0 ;i-- )
          {
               System.out.print(ch[i]);
          }
          */
         
     }
}

---

数组查找：

二分查找（折半查找）：  必须保证数组是有序的。原始数组是有序的。