黑马程序员——3,JAVA基础（函数，数组相关）

最新推荐文章于 2015-11-18 14:57:20 发布

蓝莓浆糊饼干

最新推荐文章于 2015-11-18 14:57:20 发布

阅读量656

点赞数

分类专栏： Java学习笔记文章标签：黑马程序员

本文链接：https://blog.csdn.net/dangaodeaiyi/article/details/46757735

版权

Java学习笔记专栏收录该内容

40 篇文章 0 订阅

订阅专栏

-----------android 培训、java培训、java学习型技术博客、期待与您交流！------------

3,JAVA基础（函数，数组相关）

一：函数----》

//函数：在类中有特定功能的小程序（方法）
/*
  函数的格式：
  修饰符 返回值类型  函数名（参数类型  形式参数1，参数类型 形式参数2）
  {
          执行语句；
        //  return返回值；//该句看情况而定
  }
 
*/
 
class   Hanshu
{
         public  static void main(String[]args)  //主函数
         {
                   int a1 = jiafa(10);   
                   int a2 = jiafa(20);
                    jiafa1(30);
                   System.out.println("a1="+a1+";a2="+a2);
         }
 
         public  static   int jiafa(int n)  //具有独立的功能的代码段，提高了代码的复用性
         {
         return n+10;
         }
   /*
   函数之间不可以定义函数，函数只能够调用函数，
   定义函数时，函数结果返回给调用者，交由调用者处理
  
   */
     public  static  void  jiafa1(int n)  // void表示函数没有具体返回值
    {
         System.out.println(n+10);
         //return;    由于函数没有返回值，所以这个函数里面的return可以不写
    }
}

编译运行结果如图1

图1

关于return返回值的一些常见写法：

  public   static    int    bijiao(int n1,int n2)  //具有独立的功能的代码段，提高了代码的复用性
   {
          return    n1==n2;  //n1与n2做比较，返回值是布尔类型的，要么为true，要么为false
   }

public    static   int    bijiao2(int n1,int n2)  //具有独立的功能的代码段，提高了代码的复用性
    {
            return (n1>n2)?n1:n2;  //这是三元运算符，n1与n2做比较，当n1大于n2时，返回n1；否则返回n2
    }

/*
函数例子演示
定义功能：打印矩形
思路：1，确定结果
      2，确定有没有未知内容
 
*/
 
class Hanshu1
{
          publicstatic void main(String[] args)
          {
                   dayin(5,6);
                   System.out.println("HelloWorld!");
          }
 
   public   static   void   dayin(int n1,int n2) //这是打印函数，没有返回值
          {
          for(inta=0;a<n1;a++)   //确定行数
                   {
          for(int b=0; b<n2;b++)  //确定列数
                   {
                    System.out.print("&");
                    }
          System.out.println();
                   }
          }
                  
}

编写函数：

功能：可以打印九九乘法表（可以根据用户需要打印到第几行）

public   static void dayin99(int n)   //这里添加了一个新的功能，可以调控打印到乘法表的第几行
          {
               for(int a=1;a<=n;a++)
                   {
                     for(int b=1;b<=a;b++)
                   {
 
        System.out.print(a+"*"+b+"="+a*b+"\t");
                    }
        System.out.println();
                   }
          }

而另外一种是直接打印完整的99乘法表：

  public  static  void   dayin99()   //这里是直接打印99乘法表
          {
                   for(int a=1;a<=9;a++)
                   {
                     for(int b=1;b<=a;b++)
                     {
                       System.out.print(a+"*"+b+"="+a*b+"\t");
                      }
                     System.out.println();
                   }
         
         
          }

如果以上两个函数同时出现在同一个类中，就会出现重载。函数的重载：

在同一个类中，可以存在一个以上的同名函数，要求参数个数或者参数类型不一样。

观察函数的重载只看函数的参数列表就可以了。重载和返回值类型没有关系，和参数列表顺序有关系。

举例子：

在同一个类中，对于函数void lizi(int x,char y,double z){}来说，

void  lizi(int a,char b,double c){}       //没有和它重载，因为两者一样
int    lizi(int x,double z,char y){}      //这个重载了，参数列表顺序不一样（顺序不同导致参数类型不一样）。
int   lizi(int x, char y){}               //这个也是重载了，参数个数不一样。
Int  lizi(int a,char b,double c){}        //这个则是不可以与题目中的函数放在同一个类里面。

二：数组----》

数组：同一种类型数据的集合（数组就是容器）自动给数组中元素从0开始编号。

格式：元素类型[] 数组名=new 元素类型[元素个数或数组长度]

例如int[] a=new int[5];

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

例如int[] a=new int[]{3,4,5,6,2};

int[] a=new{3,4,5,6,2};

可以用这个方法直接获取数组元素个数：数组名.length

布尔类型的数组的元素默认值是false；

内存结构：

栈内存：存放局部变量，数据使用完了所占空间自动释放

堆内存：1，数组和对象，通过new建立的实例都放在堆内存中

2，每一个实体都有内存地址值

3，实体中的变量都有默认初始化值

4,实体不在被使用，会在不确定时间内被垃圾回收站回收

例如

int[] a=new int[5]; 在堆内存里面就有了数组实体,栈内存中的a指向这个数组

int[] b=a; 这个a与b都是同时指向堆内存中的同一个数组

b[2]=11; 数组中角标为2的元素被改写成11

如果此时输出打印a[2]的话，也是会打印出11，因为a与b同时指向一个数组。

还有一种情况如下：

int[]     a=new     int[5];
System.out.println(a[5]);这种情况是属于角标越界，编译不会提示错误，但是运行时会提示异常。

class Shuzhu
{
          public  static void main(String[] args)
          {
               int[] a={10,52,48,36,4,15,25};
               printshuzhu(a) ;
 
              //System.out.println(a);这句话不是打印所有元素，而是会打印数组的哈希值
              System.out.println("HelloWorld!");
          }
         public static void printshuzhu(int[] a) //遍历数组元素并打印出来
          {
             for(int x=0;x<a.length;x++)
             {
               System.out.print(a[x]+";");
            
             }
          }
}

关于数组的一些编程应用：

 public static int getmax(int[] a) //这是第一种得到数组最大值的方法
          {
                  int max=a[0];
                   for(intx=0;x<a.length;x++)
                   {
                      if(max<a[x])
                      max=a[x];
                   }
                   returnmax;
          }
public static int getmax2(int[] a)   //这是第二种得到数组最大值的方法，采用的是读取角标的方法
          {
              int max=0;
                   for(intx=0;x<a.length;x++)
                   {
                      if(a[x]>a[max])
                               max=x;
 
                   }
          return  a[max];
          }

选择排序法：

原理：先把第一个和后面所有元素对比，选出最大值放在第一位；接着把第二位和后面所有元素对比，选出最大值放在第二位，如此类推

class Shuzhu
{
          publicstatic void main(String[] args)
          {
               int[] a={10,52,48,36,4,15,25};
              //Arrays.sort(a);这也是用来数组排序的，常用于开发中
               xuanzepaixu( a);  //这里是先排序了
               dayin( a);       //打印出来的已经从大到小排好顺序的数组了
                  
          }
         public  static  void  xuanzepaixu(int[] a)  //这是选择排序方法
          {
                   int   s=0;
             for(int x=0;x<a.length-1;x++)
             {
                for(int y=x+1;y<a.length;y++)
                     {
                              if(a[x]<a[y])
                              {
                                        s=a[x];
                                        a[x]=a[y];
                                        a[y]=s;
                              }
 
                     }
             }
          }
          public   static   void dayin(int[] a) //这是打印方法
          {
              for(int x=0;x<a.length;x++)
                   {
                            System.out.print(a[x]+";");
 
                   }
          }
 
 
}

编译运行结果如图2所示

图2

冒泡排序：

public    static   void    maopaopaixu(int[] a)//冒泡排序
          {
                   int   s=0;    //设置第三方变量
                   for(int   x=0;x<a.length-1;x++)  //决定冒泡的次数
                   {
                            for(int   y=0;y<a.length-x-1;y++)  //决定在每次冒泡过程中与相临元素比较的次数
                            {
                                      if(a[y]>a[y+1])
                                      {
                                               s=a[y];
                                               a[y]=a[y+1];
                                               a[y+1]=s;
                                      }
                            }
                  
                   }
         
          }
public  static  void  huanwei(int[] a,int b,intc)//位置换取的函数，可以使得上面的函数调用
          {
                   int   s=0;
                   if(a[b]>a[c])
                                      {
                                               s=a[b];
                                               a[b]=a[c];
                                               a[c]=s;
                                      }
 
          }

图3是折半查找

图3

折半查找的原理：

max和min这两个指示头不断的相对缩，两者的距离越来越小，当然，也不能排除要查找的数字不在这个数组里面，而这个又延伸出另外一个查数字的问题，其实当min大于max的时候，就可以确定min就是要插入的数字所在位置的数组角标。

进制之间的相互转化：

          //十进制变十六进制
            public static void  toshiliou(int n)
          {
                    for(int x=0;x<8;x++)
                   {
                             int t=n&15;//位与15，相当于二进制中每四位一段
                             if(t>9)
                             System.out.println((char)(t-10+'A'));
                             //注意要利用转换，
                             //仅仅是打印t-10+'A'的结果不是字符，而是数字！
                             //所以要转化为字符形式！
                             else
                             System.out.println(t);
                             n=n>>>4;//要转变进制的数字无符号右移4位
 
                     }
           
            }

再修改一下：

public   static void  toshiliou(int n)
          {
                    StringBuffer a=new StringBuffer();//建立一个装数据的容器
                    for(int x=0;x<8;x++)
                   {
                           
                             int   t=n&15;//位与15，相当于二进制中每四位一段
                             if(t>9)
                                      a.append(char)(t-10+'A'));//把数装进去
                             
                             else
                                       a.append(t);
                             n=n>>>4;//要转变进制的数字无符号右移4位
 
                     }
            System.out.println(a.reverse());//输出打印时反向打印
            }

查表法，十进制转成十六进制：

 public   static   void  toshiliou(int n)
{
 char[]   rq={'0','1','2','3'
          ,'4','5','6','7'
                      ,'8','9','A','B'
                      ,'C','D','E','F'};
char[]   rq1=new char[8];
 for(int x=0;x<8;x++)
{
           int t=n&15;
           rq1[x]=rq[t];
           n=n>>>4;
 
 }
 for(int x=rq1.length-1;x>=0;x--)
{
           System.out.print(rq1[x]+",");
 
 }
}
//查法表的意义在于可以对着数组角标来放进数据，再读取出来（注意顺序）
//改进方法查表法，十进制转十六进制
 public   static void  toshiliou(int n)
{
 char[] rq={'0','1','2','3'
          ,'4','5','6','7'
                      ,'8','9','A','B'
                      ,'C','D','E','F'};
 char[] rq1=new char[8];
 int   pos=rq1.length; //设定一个指针
 while(n!=0)
  {
            pos--;
            int t=n&15;
            rq1[pos]=rq[t];//反向装入数组内
            n=n>>>4;
 
  }
 for(int  x=pos;x<rq1.length;x++)//所以，这里就变成了从指针开始向最高位打印
          {
            System.out.print(rq1[x]+",");
           }
 
}
 
 
//最后的进制转化的简化
 public  static   void  zhuanhua(int n,int base,intoffset)
{
 char[] rq={'0','1','2','3'
          ,'4','5','6','7'
                      ,'8','9','A','B'
                      ,'C','D','E','F'};
 char[] rq1=new char[32];
 int  pos=rq1.length; //设定一个指针
 while(n!=0)
  {
            pos--;
            int t=n&base;
     rq1[pos]=rq[t];//反向装入数组内
            n=n>>>offset;
 
  }
 for(int x=pos;x<rq1.length;x++)//所以，这里就变成了从指针开始向最高位打印
          {
            System.out.print(rq1[x]+",");
  }
 }

-----------android 培训、java培训、java学习型技术博客、期待与您交流！------------