亲宝软件园·资讯

展开

Java方法及数组相关原理解析

None1014 人气:0

方法

设计方法的原则:方法的本意是功能块,就是实现某个功能的语句块的集合。我们设计的方法,最好保持方法的原子性,就是一个方法只完成1个功能,有利于后期的扩展。

方法重载

重载就是在一个类中,有相同的函数名称,但参数不同的函数

重载规则:

实现原理:

方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错。

命令行传参

public static void main(String[] args) {
    for (int i=0;i<args.length;i++){
      System.out.println("args["+i+"]:"+args[i]);
    }
  }//传递命令行参数给main函数

要在 cmd 界面下才能运行!!!

可变参数

JDK 1.5开始,Java支持传递同类型的可变参数给一个方法。

在方法声明中,在指定参数类型后加一个省略号(..)。

一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public static void main(String[] args) {
    //调用
    printMax(34,3,3,2,56.5);
    printMax(new double[]{1,2,3});
  }

  public static void printMax(double... numbers){//可变参数
    if (numbers.length==0){
      System.out.println("No argument passed");
      return;
    }

    double result=numbers[0];

    //排序
    for (int i = 1; i < numbers.length; i++) {
      if(numbers[i]>result){
        result=numbers[i];
      }
    }
    System.out.println("The max value is "+result);
  }

递归

A方法调用A方法!自己调用自己!

递归结构包括两个部分:

递归头:什么时候不调用自身方法。如果没有头,将陷入死循环。

递归体:什么时候需要调用自身方法

public static int f(int n){
    if(n==1){
      return 1;
    }else {
      return n*f(n-1);
    }
  }

数组

数组是相同类型数据的有序集合.

数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。

其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组的声明

int[] nums=new int[5];
nums[0]=1;nums[1]=2;nums[2]=3;nums[3]=4;nums[4]=5;

数组的三种初始化

//1静态初始化
int[] a={1,2,3,4,5,6,7,8};
System.out.println(a[0]);

//2动态初始化 :包含3默认初始化
int[] b=new int[10];
b[0]=10;
b[1]=10;
System.out.println(b[0]);
System.out.println(b[1]);
System.out.println(b[2]);//默认初始化,输出结果为0

数组的四个基本特点

数组边界

数组的应用

//反转数组
	public static int[] reverse(int[] arrays){
    int[] result = new int[arrays.length];
    for (int i = 0,j=result.length-1; i <arrays.length ; i++,j--) {
      result[j]=arrays[i];
    }
    return result;
  }

多维数组

int a[][]=new int[2][5];//以上二维数组可以看成一个两行五列的数组

Array类

查看 JDK 帮组文档!!!

常用功能:

给数组赋值:fill

给数组排序:sort

比较数组:equals 比较数组中元素值是否相等

查找数组元素:binarySearch 方法能对排序好的数组进行二分查找法操作

冒泡排序

  public static int[] sort(int[] array){
//   冒泡排序
    int temp=0;
    for (int i = 0; i < array.length-1; i++) {
      for (int j = 0; j < array.length-1-i; j++) {//i表示已经排好的数字个数,所以在内层循环时减去i,减少比较次数
        if(array[j+1]<array[j]){
          temp=array[j];
          array[j]=array[j+1];
          array[j+1]=temp;
        }
      }
    }
    return array;
  }

稀疏数组

稀疏数组的处理方式是:

记录数组一共有几行几列,有多少个不同值

把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模

//看代码才能看懂
  public static void main(String[] args) {
    //稀疏数组
    int[][] array1=new int[11][11];
    array1[1][2]=1;
    array1[2][3]=2;

    System.out.println("输出原始数据:");

    for (int[] ints:array1) {
      for(int anint:ints){
        System.out.print(anint+"\t");
        //输出原始数组
      }
      System.out.println();
    }
    System.out.println("================");
    //转换为稀疏数组
    //获取数组中有效值
    int sum= 0;
    for (int i = 0; i < 11; i++) {
      for (int j = 0; j < 11; j++) {
        if(array1[i][j]!=0){
          sum++;
        }
      }
    }
    System.out.println("有效值个数:"+sum);

    //创建稀疏数组
    int[][] array2=new int[sum+1][3];
    array2[0][0]=11;
    array2[0][1]=11;
    array2[0][2]=sum;
    //遍历二维数组,将有效值存在稀疏数组中
    int count=0;
    for (int i = 0; i < array1.length; i++) {
      for (int j = 0; j < array1[i].length; j++) {//二维数组每一行的长度
        //形成稀疏数组
        if(array1[i][j]!=0){
          count++;
          array2[count][0]=i;
          array2[count][1]=j;
          array2[count][2]=array1[i][j];
        }
      }
    }
    //输出稀疏数组
    System.out.println("稀疏数组");

    for (int i = 0; i < array2.length; i++) {
      System.out.println(array2[i][0]+"\t"
          +array2[i][1]+"\t"
          +array2[i][2]+"\t");
    }

    System.out.println("================");
    System.out.println("还原");
    int[][] array3=new int[array2[0][0]][array2[0][1]];

    //还原值
    for (int i = 1; i < array2.length; i++) {
      //在还原数组中将坐标与值相对应
      array3[array2[i][0]][array2[i][1]]=array2[i][2];
    }

    //打印输出
    System.out.println("输出还原数组:");

    for (int[] ints:array3) {
      for(int anint:ints){
        System.out.print(anint+"\t");
        //输出还原数组
      }
      System.out.println();
    }
  }

加载全部内容

相关教程
猜你喜欢
用户评论