Java语言基础(三)函数、数组

常用的转义字符

        \n 回车
        \t 制表符
        \b 退格
        \r 按下回车键
        windows系统中回车符其实是由两个符号组成的\r\n
        linux中回车符是\n

函数
    什么是函数
        函数就是定义在类中的具有特定功能的一段独立小程序
        函数也称为方法
    定义函数的格式
        修饰符 返回值类型 函数名(参数类型 形参2，参数类型 形参2，...)    //函数名有多个单词时，第一个单词小写，后面的单词首字母大写
        {
            执行语句;
            return 返回值;
        }
    特殊情况：
        功能没有具体的返回值。    这时，retrun的后面直接用分号结束，因为没有具体值，所以不可以写具体的数据类型，
        在java中只能用一个关键字void来表示这种情况。
        注意：如果返回值类型为void，那么函数中的return语句可以省略不写。
    特点：
        1.定义函数可以将功能代码进行封装
        2.便于对该功能进行服用
        3.函数只有被调用才会被执行
        4.函数的出现提高了代码的复用性
    注意：
        函数中只能调用函数，不能在函数内部定义函数。
        定义函数时，函数的结果应该返回给调用者，交由调用者处理。
 

class FunctionDemo3
 {
     public static void main(String[] args)
     {
         System.out.println(add(4,5));
         draw(7,9);
         System.out.println(equals(5,6));
         System.out.println(getMax(4,5));
     }

     /*
     需求1：定义一个功能，完成两个整数的和的获取
     思路：既然定义功能，就是可以用函数来体现
                 如何定义一个函数？
                 通过两个明确来完成
     明确1：这个功能的结果是什么？ 是两个整数的和，是功能的结果，所以该功能的返回值类型是int
                 明确返回值的类型。
     明确2：这个功能实现过程中是否需要未知内容参与运算？ 需要加数和被加数。
                 这就是函数的参数列表（参数的个数，参数的类型）
                 明确参数列表
     注意：返回值类型和参数类型没有直接关系
     */
     public static int add(int a,int b)
     {
         return a+b;
     }

     /*
     需求2 定义一个功能，在控制台画一个矩形
     明确1：这个功能的结果是什么？没有结果，直接打印到控制台
     明确2：这个功能实现过程中是否需要未知内容参与运算？ 行和列不确定，需要两个整数int
     */
     public static void draw(int row,int col)
     {
         for (int x=1;x<=row ;x++ )
         {
             for (int y=1;y<=col ;y++ )
             {
                 System.out.print("*");
             }
             System.out.println();
         }
     }

     /*
     需求3 定义一个功能，比较两个数是否相等
     明确1：这个功能的结果是什么？有结果，true或false,返回值为boolean
     明确2：这个功能实现过程中是否需要未知内容参与运算？ 两个数不确定，需要两个整数int
     */
     public static boolean equals(int a,int b)
     {
         /*
         if(a==b)
             return true;
         else
             return false;
         */
         return a==b;//a==b,本身是在进行比较运算，结果是true或false，不要要是用(a==b)?true:false
     }
     /*
     需求4 定义一个功能，获取两个整数中较大的那个数
     明确1：这个功能的结果是什么？有结果，返回较大的整数
     明确2：这个功能实现过程中是否需要未知内容参与运算？ 参与比较的数不确定，需要两个整数int
     */
     public static int getMax(int a,int b)
     {
         return (a>b)?a:b;
     }
 }

    函数的重载（overload）
        重载的概念
            在同一个类中，允许存在一个以上的同名名称，只要他们的参数个数或者参数类型不同即可。
        重要特点
            与返回值类型无关，只看参数列表
  

class FunctionDemo4
  {
      public static void main(String[] args)
      {
          System.out.println(add(1.2,2.5));
          printCFB(5);
          printCFB();
      }
      /*
      函数的重载
      1.同一个类
      2.同名
      3.参数个数不同或参数类型不同
      4.函数重载和返回值类型无关
      5.java是严谨性语言，如果函数出现调用的不确定性，会编译失败
      */

       //加法运算，两个整数的和
      public static int add(int a,int b)
      {
          return a+b;
      }

       //加法运算，两个小数的和
       public static double add(double a,double b)
      {
           return a+b;
       }

       //加法运算，三个整数的和
       public static int add(int a,int b,int c)
      {
           return a+b+c;
       }

       /*
       打印乘法表
       */
       public static void printCFB(int num)
      {
          for (int x=1;x<=num ;x++ )
          {
              for (int y=1; y<=x;y++ )
              {
                  System.out.print(y+"*"+x+"="+y*x+"\t");//使用制表符'\t'能够实现输出时对齐
              }
              System.out.println();
          }
       }

       /*
       打印标准乘法表
       */
       public static void printCFB()
      {
              printCFB(9);
       }
  }

数组(引用数据类型)
    概念：同一种类型数据的结合，其实数组就是一个容器
    数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素
    格式1
        元素类型[] 数组名=new 元素类型[元素个数或数组长度];
        int[] arr=new int[5]
    格式2
        元素类型[] 数组名=new 元素类型[] {元素，元素，……};
        int[] arr=new int[]{3,5,1,7};
        int[] arr={3,5,1,7};
    内存的划分
        1.寄存器
        2.本地方法区
        3.方法区
        4.栈内存
             存储的都是局部变量（程序运行时，方法要进栈，否则，局部变量无法进栈）。
             而且变量所属的作用域一旦结束，该变量就自动释放
        5.堆内存
             存储的是数组和对象（其实数组就是对象）；凡是new建立的，都在堆中
             特点：
             1.每一个实体都有首地址值
             2.堆内存中的每个变量都有默认初始化值，根据类型的不同而不行（整数是0，小数是0.0或0.0f，boolean是false，char'\u0000'）
             3.垃圾回收机制
       
        arr不做任何实体指向，则arr=null；//数组arr为空，所有元素的值都为默认初始化值
        int[] x=new int[3];//假设首地址为0x0034，数组内元素为x{0,0,0}
        int[] y=new int[3];//假设首地址为0x0087，y{0,0,0}
        x[0]=9;//x{9,9,9}
        y[0]=34;//x{34,0,0}
        x=y;//首地址变为0x0087，x{34,0,0}
        多个数组变量可以指向同一个实体。
  

class ArrayDemo
  {
      public static void main(String[] args)
      {
          //元素类型[] 数组名=new 元素类型[元素个数或数组长度];
          int[] arr=new int[3];
          arr[0]=89;

          System.out.println(arr[0]);
      }
  }

数组
    数组的遍历
  

class ArrayDemo3
  {
      public static void main(String[] args)
      {
          /*
          需要一个容器，但是不明确容器的具体数据
          */
          //int[] arr=new int[3];

          /*
          需要一个容易，存储已知的具体数据
          */
          //int[] arr=new int[]{89,34,270,17};
          int[] arr={89,34,270,17}; //静态初始化方式

          /*
          对数组操作最基本的动作就是存和取
          核心思想：就是对角标的操作。
          */
          //数组的遍历
          for (int i=0;i<arr.length ;i++ ) //arr.length，可以获取数组的长度
          {
              System.out.println("arr["+i+"]="+arr[i]+";");
          }
      }
  }

    获取数组中的最值
   

class  ArrayDemo4
   {
       public static void main(String[] args)
       {
           int[] arr={-34,-19,-11,-109,-3,-56};
           System.out.println("max="+getMax(arr));
           System.out.println("max="+getMax_2(arr));
           System.out.println("min="+getMin(arr));
       }

       /*
       获取数组中的最大值
       思路：
           1.需要进行比较，并定义变量记录每次比较后较大的值
           2.对数组中的元素进行遍历取出，和变量中记录的元素进行比较，
           如果遍历到的元素大于变量中记录的元素，就用变量记录较大的值
           3.遍历结束，该变量记录就是最大值

       定义一个功能来实现：
       明确1：结果
                   是数组中的元素，int型
       明确2：未知内容
                   数组
       */
       public static int getMax(int[] arr)
       {
           //定义变量记录较大值
           int max=arr[0];
           for (int i=1;i<arr.length ;i++ )
           {
               if(arr[i]>max)
                   max=arr[i];
           }
           return max;
       }

       public static int getMax_2(int[] arr)
       {
           //定义变量记录较大值
           int maxelement=0;
           for (int i=0;i<arr.length ;i++ )
           {
               if(arr[i]>arr[maxelement])
                   maxelement=i;
           }
           return arr[maxelement];
       }
   }

    排序
        选择排序
   

class SelectSort
   {
       public static void main(String[] args)
       {
           int[] arr={34,19,11,109,3,56};
           getArr(arr);
           selectSort(arr);
           getArr(arr);
           selectSort_2(arr);
           getArr(arr);
       }

       /*
       选择排序：
       思路：
           1.第一个元素与后边的所有元素比较，将最小值放在arr[0]，比较次数为arr.length-1
           2.需要多轮排序，且每次的比较次数 -1
           3.需要一个变量作为中转
           4.返回排好序的数组
       */
       public static void selectSort(int[] arr)
       {
           for (int i=0;i<arr.length-1 ;i++ ) //外循环中最多取到arr[arr.length-1]即可，此时就是arr[length-1]与arr[length]比较，比较之后结束
               for (int j=i+1;j<arr.length ;j++ )
               {
                   if (arr[i]>arr[j])
                   {
                       swap(arr,i,j);
                   }
               }
       }

       /*
       高效选择排序
       使用变量记录角标，获得最小值角标之后，只进行一次交换，提高了效率
       */
       public static void selectSort_2(int[] arr)
       {
           for (int i=0;i<arr.length-1 ;i++ )
           {
               int num=arr[i],index=i;
               for (int j=i+1;j<arr.length ;j++ )
               {
                   if (num>arr[j])
                   {
                       num=arr[j];
                       index=j;
                   }
               }
               swap(arr,i,index);
           }
       }

       /*
       遍历取出数组中的元素
       */
       public static void getArr(int[] arr)
       {
           System.out.print("[");
           for (int i=0;i<arr.length ;i++ )
           {
               if(i!=arr.length-1)
               {
               System.out.print(arr[i]+","); //使用System.out.print(arr[i]+',')，输出结果为47556378100109，而使用System.out.print(arr[i]+“,")则能正常输出3,11,19,34,56,109,
               //解决：使用' '，在输出时强制转换为int型（int类型+char类型=int类型），而使用" "，int类型+string类型不能进行转化，只能在输出的数后边添加字符串
               }
               else
                   System.out.print(arr[i]);
           }
           System.out.print("]");
           System.out.println();
       }

       /*
       实现交换功能：实现arr[i]与arr[i+1]值的交换
       */
       public static void swap(int[] arr,int a,int b)
       {
           int temp=arr[a];
           arr[a]=arr[b];
           arr[b]=temp;
       }
   }

        冒泡排序
       

class BubbleSort
       {
           public static void main(String[] args)
           {
               int[] arr={34,19,11,109,3,56};
               getArr(arr);
               bubbleSort(arr);
               getArr(arr);
               bubbleSort_2(arr);
               getArr(arr);
           }

           /*
           冒泡排序
               1.相邻两个元素相比，较大的后移（下沉）
               2.下一次比较比本次比较次数-1,且最后面的i个元素已排好序，不需要比较
               3.总共需要排序arr.length-1次
               4.内循环-1，为了避免角标越界；为了让外循环增加一次，内循环参数与比较的元素个数递减
           */
           public static void bubbleSort(int[] arr)
           {
               for (int i=0;i<arr.length-1 ;i++)
               {
                   for (int j=0;j<arr.length-1-i;j++ ) //外循环次数+1，则内循环需要比较次数-1
                   {
                       if (arr[j]>arr[j+1])
                       {
                           swap(arr,j,j+1);
                           //int temp;
                           //temp=arr[j];
                           //arr[j]=arr[j+1];
                           //arr[j+1]=temp;
                       }
                   }
               }
           }

           /*
           1.外循环从最后一个元素开始取值
           2.外循环每次角标-1
           3.内循环的比较次数随着外循环的变化而变化
           */
           public static void bubbleSort_2(int[] arr)
           {
               for (int i=arr.length-1;i>0 ;i-- )
               {
                   for (int j=0;j<i ;j++ )
                   {
                       if (arr[j]>arr[j+1])
                       {
                           swap(arr,j,j+1);
                           //int temp;
                           //temp=arr[j];
                           //arr[j]=arr[j+1];
                           //arr[j+1]=temp;
                       }
                   }
               }
           }

           /*
           遍历输出数组元素
           */
           public static void getArr(int[] arr)
           {
               System.out.print("[");
               for (int i=0;i<arr.length ;i++ )
               {
                   if(i!=arr.length-1)
                   {
                       System.out.print(arr[i]+",");
                   }
                   else
                       System.out.print(arr[i]);
               }
               System.out.print("]");
               System.out.println();
           }

           /*
           实现交换功能：实现arr[i]与arr[i+1]值的交换
           */
           public static void swap(int[] arr,int a,int b)
           {
               int temp=arr[a];
               arr[a]=arr[b];
               arr[b]=temp;
           }
       }

    数组的查找
      

/*
      面试题
      给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，
      那么这个元素的存储的角标如何获取
      {13,15,19,20,33,45,78,106}
      */
      import java.util.*;
      class ArrayDemo5
      {
          public static void main(String[] args)
          {
              //int[] arr={4,1,5,7,3,8,2};
              int[] arr={13,15,19,28,33,45,78,106};
              //int index=getIndex(arr,50);
              //System.out.println("index="+index);
              int index1=halfSearch(arr,50);
              System.out.println("index="+index1);
              int index2=halfSearch_2(arr,50);
              System.out.println("index="+index2);

              int index3=Arrays.binarySearch(arr,50);//java中的折半查找
              /*
              如果存在，则返回的是具体的角标位置；不存在，则返回的是 -插入点-1。
              */
              System.out.println("indxe="+index3);


          }

          /*
          数组常见功能：查找。
          1.确定需要查找的数组
          2.确定需要查找的元素
          需要两个形参
          */
          public static int getIndex(int[] arr,int key)
          {
              for (int i=0;i<arr.length-1 ;i++ )
              {
                  if (arr[i]==key)
                  {
                      return i;
                  }
              }
              return -1;
          }

          /*
          折半查找（二分查找）
              1.数组必须为有序数组
              2.头角标和尾角标可能变化，故需要变量min，max
              3.中间角标为mid=(min+max)/2
              4.如果要查找的值key>arr[mid],则该值可能在后半部分，min+1；否则，可能在前半部分，max-1
              5.当max<min时，停止查找，该数组中没有要查找的值key
          */
          public static int halfSearch(int[] arr,int key)
          {
              int max,min,mid;
              min=0;
              max=arr.length-1;
              mid=(min+max)/2;
              while(key!=arr[mid])//当key==arr[mid]时，查找成功，停止查找
              {
                  if (key>arr[mid])
                      min=mid+1;
                  else if (key<arr[mid])
                      max=mid-1;
                  if(max<min)
                      //return -1;//查找结束，该数组中不存在此元素
                      return  min;//返回插入点
                  mid=(min+max)/2;
              }
              return mid;
          }

          public static int halfSearch_2(int[] arr,int key)
          {
              int max,min,mid;
              min=0;
              max=arr.length-1;


              while(min<=max)//当min>max时，整个数组已查找完毕，停止查找
              {
                  mid=(min+max)/2;
                  if (key>arr[mid])
                      min=mid+1;
                  else if (key<arr[mid])
                      max=mid-1;
                  else
                      return mid;
              }
              //return -1;//查找结束，该数组中不存在此元素
              return min;//返回插入点
          }
      }

进制转换

class ArrayTest3 
{
    public static void main(String[] args) 
    {
        toHex(60);
        toBinary(6);
        toOctal(8);
        System.out.println(Integer.toBinaryString(6));//二进制转换

    }
    //十进制转十六进制
    public static void toHex(int num)
    {
        trans(num,15,4);
    }
    //十进制转八进制
    public static void toOctal(int num)
    {
        trans(num,7,3);
    }
    //十进制转二进制
    public static void toBinary(int num)
    {
        trans(num,1,1);
    }
    public static void trans(int num,int base,int offset)
    {
        if(num==0)
        {
            System.out.println("0");
            return ;//如果不写return,则后边的代码会继续执行
        }
        char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        /*
        查表时会查到比较多的数据，数据一多，就先存储后再进行操作
        所以，需要定义一个数组，作为临时容器
        */
        char[] arr=new char[32];
        int pos=arr.length;
        while(num!=0)
        {
            int temp=num&base;
            arr[--pos]=chs[temp];
            num=num>>>offset;
        }
        printHex(arr,pos);
        System.out.println();

    }

    public static void printHex(char[] arr,int pos)
    {
        for (int x=pos;x<=arr.length-1 ;x++ )
        {
                System.out.print(arr[x]);
        }
    }
}

二维数组
    格式1：int[][] arr=new int[3][2];
        定义了名称为arr的二维数组
        二维数组中有3个以为数组
        每一个一维数组中有2个元素
        一维数组的名称分别为arr[0],arr[1],arr[2]
        给第一个一维数组的1脚标位赋值78：arr[][1]=78;
    格式2：int [][] arr=new int[3][];
        分别对二维数组中的每一个小数组进行初始化：
        arr[0]=new int[2];
        arr[1]=new int[1];
        arr[2]=new int[3];
    格式3：
        静态定义一个二维数组
        int[][] arr={{3,1,7},{5,8,2,9},{4,1}};

  /*
二维数组定义的格式
*/
class  Array2Demo
{
    public static void main(String[] args)
    {
        //int[] arr=new int[3];
        //System.out.println(arr);//[I@bdb503，@左边是实体的类型，右边是实体的哈希值

        //int[][] arr=new int[3][2];//创建一个二维数组，该数组中有3个一维数组，每个一维数组中有2个元素

        //System.out.println(arr);//直接打印二维数组，[[I@bdb503，@左边有两个[，是二维数组
        //System.out.println(arr[0]);//打印二维数组中脚标0的一维数组，@左边有1个[，是一维数组
        //System.out.println(arr[0][0]);//打印二维数组中脚标0的一维数组中脚标为0的元素

        //int[][] arr=new int[3][];
        //System.out.println(arr);//直接打印二维数组，[[I@bdb503，@左边有两个[，是二维数组
        //System.out.println(arr[0]);//一维数组未初始化，null
        //System.out.println(arr[0][0]);//一维数组为初始化，一维数组中没有元素(不是元素为0)

        //int[][] arr=new int[3][2];
        //System.out.println(arr.length);//打印二维数组的长度，其实就是一位数组的个数
        //System.out.println(arr[1].length);//打印脚标为1的一维数组的长度


        /*
        遍历二维数组
        */
        int[][] arr={{3,1,7},{5,8,2,9},{4,1}};
        int sum=0;
        for (int x=0;x<arr.length ;x++ )
        {
            System.out.print("{");
            for (int y=0;y<arr[x].length ;y++ )
            {
                if(y!=arr[x].length-1)
                    System.out.print(arr[x][y]+",");
                else
                    System.out.print(arr[x][y]);
                sum+=arr[x][y];
            }
            System.out.println("}");

        }
        System.out.println("sum="+sum);
    }
}