您的位置：首页 > 编程语言 > Java开发

Java函数和数组

2016-06-28 09:28 453 查看

函数使用

函数概念

package com.cloud.day3;
/*
函数：
函数的作用：为了提高功能代码的复用性。
函数的定义格式:

修饰符返回值类型
变量名(形式参数){

函数体
   }

函数的特点：
   1.
函数是把一个功能的代码封装起来以达到提高功能代码的复用性。
   2.
函数定义好之后，需要调用才能执行的。
   3.
如果一个函数没有返回值类型，那么就使用void关键字表示。

需求:
定义一个函数判断分数的等级，然后返回分数对应的等级。
   "a等级"
*/
public
class Demo1 {
   public
static void main(String[] args) {
      String result = getScore(80);
      System.out.println(result);
   }
   public
static String getScore(int score){
      if(score>100){
        return
"你很优秀...";
      }else
if(score<100 && score>60){
        return
"还不错...";
      }else{
        return
"继续努力...";
      }
   }
}

函数中return关键字

package com.cloud.day3;
/*
注意：如果一个函数的返回值类型是具体的数据类型，那么该函数就必须要保证在任意情况下都保证有返回值。（除了返回值类型是void以外）

return
关键字的作用：
   1.
返回数据给函数的调用者。
   2.
函数一旦执行到了return关键字，那么该函数马上结束。 (能结束一个函数)

注意：一个函数的返回值类型是void，那么也可以出现return关键字，但是return关键字的后面不能有数据。

break关键字与return关键字的区别：
   1.break关键字是结束一个循环。
   2. return关键字是结束一个函数。
*/
public
class Demo2 {
   public
static void main(String[] args) {
      test1(0,1);
      test2(1,0);
   }
   public
static void test1(int a,int b){
      if(a==0){
        return ;//结束这个函数
      }
      System.out.println("not do this print!!");
   }
   public
static void test2(int a,int b){
      for(int i=0;i<3;i++){
        System.out.println("hello");
        break;
//跳出这个循环
      }
      System.out.println("will do this print!");
   }
}

函数重载

package com.cloud.day3;
/*
需求：定义一个函数做加法功能。
函数的重载：在一个类中出现两个或者两个以上的同名函数，这个称作为函数的重载。
函数重载的作用：同一个函数名可以出现了不同的函数，以应对不同个数或者不同数据类型的参数。
函数重载的要求：
   1.
函数名一致。
   2.
形参列表不一致。（形式参数的个数或者是对应的数据类型不一致）
   3.
与函数的返回值类型是无关的。
*/
public
class Demo3 {
   public
static void main(String[] args) {
      add(1,2);
      add(1,2,3);
   }
   public
static int add(int a,int b){
      System.out.println("两个参数的和"+(a+b));
      return 12;
   }
   public
static double add(int a,int b,int
c){
      System.out.println(a+b+c);
      return 3.14;
   }
}

数组的使用

数组基础

package com.cloud.day3;
/*
数组：数组是存储同一种数据类型数据的集合容器。
数组的定义格式：

数据类型[] 变量名 = new
数据类型[长度];
分析数组：

   左边：
int[] arr    声明了一个int类型的的数组变量，变量名为arr。

int : 表示该数组容器只能存储int类型的数据。
      []
：这是一个数组类型。

arr ：变量名.


右边：new int[50];
创建了一个长度为50的int类型数组对象。
      new
：创建数组对象的关键字。

int: 表示该数组对象只能存储int类型数据。
      []：表示是数组类型。
      50 :
该数组最多能存储50个数据。数组的容量。
数组的好处：对分配到数组对象中每一个数据都分配一个编号（索引值、角标、下标）,索引值的范围是从0开始，最大是：长度-1.

局部变量：如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。
成员变量：成员变量就是定义在方法之外，类之内的.
*/
public
class Demo4 {
   public
static void main(String[] args) {
      int[] arr =
new int[4];
      arr[0] = 1;
      arr[1] = 2;
      arr[2] = 3;
      arr[3] = 4;
      for(int index = 0;index<arr.length;index++){
        System.out.println(arr[index]);
      }
   }
}

数组中异常

package com.cloud.day3;
/*
数组中最常见的问题：
   1. NullPointerException
空指针异常

原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。
   2. ArrayIndexOutOfBoundsException
索引值越界。

原因：访问了不存在的索引值。
*/
public
class Demo5 {
   public
static void main(String[] args) {
      int[] arr =
new int[5];
      arr[0] = 1;
      arr[1] = 2;
      arr[2] = 3;
      arr[3] = 4;
      //java.lang.ArrayIndexOutOfBoundsException
      //数组下表越界
      //System.out.println(arr[7]);
      //没有赋值的元素的默认的值是0
      System.out.println(arr[4]);
   }
}

数组初始化方式

package com.cloud.day3;
/*

数组的初始化方式

动态初始化:

数据类型[] 变量名 = new
数据类型[长度];

静态初始化：

数据类型[] 变量名 = {元素1，元素2.....};

如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果
数据一开始还不太明确，这时候就建议使用动态初始化。
*/
public
class Demo6 {
   public
static void main(String[] args) {
      //静态初始化数组
      int[] arr = {1,2,3,4,5};
      for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+";");
      }
      //动态初始化
      int[] arr1 =
new int[2];
      arr1[0] = 2;
      arr1[1] = 3;
   }
}

数组找最大

package com.cloud.day3;
/*
需求：定义一个函数接收一个int类型的数组对象，找出数组对象中的最大元素返回给调用者。
*/
public
class Demo7 {
   public
static void main(String[] args) {
      int[] arr={1,2,3,4};
      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;
   }
}

冒泡排序

package com.cloud.day3;
/*
需求：定义一个函数接收一个int类型的数组对象,
把数组中的最大值放在数组中的第一位。
选择排序(直接排序)：使用一个元素与其他的元素挨个比较一次，符合条件交换位置。
*/
public
class Demo8 {
   public
static void main(String[] args) {
      int[] arr={1,2,3,4,5};
      sortArr(arr);
   }
   public
static void sortArr(int[] arr){
      int temp = 0;
      for(int i=0;i<arr.length;i++){
        for(int j=i+1;j<arr.length;j++){
           if(arr[j]>arr[i]){
              temp = arr[j];
              arr[j] = arr[i];
              arr[i] = temp;
           }
        }
      }
      //遍历数组
      for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+";");
      }
   }
}

案例二：

package com.cloud.day3;
/*
需求：定义一个函数接收一个int类型的数组对象,
把数组中的最大值放在数组中的最后一位。
冒泡排序：冒泡排序的思想就是使用相邻的两个元素挨个比较一次，符合条件交换位置。
*/
public
class Demo9 {
   public
static void main(String[] args) {
      int[] arr={1,2,3,4,5};
      bubbleArr(arr);
   }
   public
static void bubbleArr(int[] arr){
      for(int i=0;i<arr.length-1;i++){//控制循环次数
        for(int j=0;j<arr.length-1-i;j++){//找出最大值
           if(arr[j+1]>arr[j]){
              int temp = arr[j+1];
              arr[j+1] = arr[j];
              arr[j] = temp;
           }
        }
      }
      //输出数组
      for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+";");
      }
   }
}

二分法

package com.cloud.day3;
/*
需求：定义一个函数接收一个数组对象和一个要查找的目标元素，函数要返回该目标元素在
数组中的索引值，如果目标元素不存在数组中，那么返回-1表示。
折半查找法(二分法):
使用前提必需是有序的数组。
*/
public
class Demo10 {
   public
static void main(String[] args) {
      int[] arr = {1,2,3,4,5,6};
      int mid =
search(arr, 3);
      System.out.println(mid);
   }
   public
static int search(int[] arr,int target){
      int max = arr.length-1;
      int min = 0;
      int mid = (min+max)/2;
      while(true){
        if(target>arr[mid]){
           min = mid + 1;
        }else
if(target<arr[mid]){
           max = mid -1;
        }else{
           return mid;
        }
        if(max<min){
           return -1;
        }

//重新计算中间的索引值
        mid = (min+max)/2;
      }
   }
}

数组反转

package com.cloud.day3;
/*
需求：定义一个函数接收一个char类型的数组对象,然后翻转数组中的元素。
char[]
arr = {'a','b','c','d','e'};
*/
public
class Demo11 {
   public
static void main(String[] args) {
      char[] arr = {'a','b','c','d','e'};
      convertArr(arr);
   }
   public
static void convertArr(char[] arr){
      for(int startIndex = 0,endIndex = arr.length-1;startIndex<endIndex;startIndex++,endIndex--){
        char temp = arr[startIndex];
        arr[startIndex] = arr[endIndex];
        arr[endIndex] = temp;
      }
      //遍历数组
      for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+";");
      }
   }
}

二维数组

package com.cloud.day3;
/*
二维数组：二维数组就是数组中的数组。
一根
变量
一盒     20根
一维数组
一条     10包   20根
二维数组

二维数组的定义格式：

数据类型[][] 变量名 = new
数据类型[长度1][长度2];

长度1：一条烟有多少盒。

长度2：一盒烟有多少根。

二维数组的初始化方式：

动态初始化:

数据类型[][] 变量名 = new
数据类型[长度1][长度2];


静态初始化：

数据类型[][] 变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}
..}
*/
public
class Demo12 {
   public
static void main(String[] args) {
      /**

int[][] arr = new int[3][4];
        1 2 3
      1 100
      2
      3
      4
      */
      int[][] arr =
new int[3][4];
      arr[1][1] = 100;
      System.out.println("数组的元素："+ arr[1][1]);
   }

}

二维数组初始化

package com.cloud.day3;
/*
静态初始化：

数据类型[][] 变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}
..}
*/
public
class Demo13 {
   public
static void main(String[] args) {
      int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};
      for(int i=0;i<arr.length;i++){
        for(int j=0;j<arr[i].length;j++){
           System.out.print(arr[i][j]+";");
        }
      }
   }
}

二维数组特点

package com.cloud.day3;
/*
数组的特点：
   1.
数组只能存储同一种数据类型的数据。
   2.
数组是会给存储到数组中的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；
   3.
数组一旦初始化，长度固定。
   4.
数组中的元素与元素之间的内存地址是连续的。
*/
class Demo14
{
   public
static void main(String[] args)

   {
      int[] arr =
new int[3];
      arr = new
int[4];
      System.out.println(arr.length);
   }
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航