数组以及方法的运用

java方法

  public static void main(String[] args) {
        int max = max(10, 20);
        System.out.println(max);
    }
    //比大小
    public  static  int max(int num1,int num2){
        int result=0;
        if (num1==num2){
            System.out.println("num1==num2");
            return  0;
        }
        if (num1>num2){
            result=num1 ;
        }else {
            result=num2;
        }
        return  result;
    }

public 是修饰词，static静态可以变成全局变量或方法，int要放回值 return 值，void不要。

因为是比大小，所以值会变，所以要定义一个变量用来存储大小值。再在main（）方法里调用max方法。

方法的重载是是方法名相同，但方法类型，个数不同即可。

//阶乘
public static void main(String[] args) {
        System.out.println(f(2));
    }
    public static int f(int n){

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

通过递归的方法，在f(int n)方法里调用f（），使用递归调用要有一个终结条件，不能无限调用

//计算器
1.写四个方法：加减乘除
2.利用循环+switch进行用户交互
3.传递需要操作的两个数
4.输出结果
package com.lang.www;

import java.util.Scanner;

public class 计算器 {
    public static void main(String[] args) {
//通过scanner类来获取用户输入
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要计算的值");
        //通过nextdouble来获取用户输入的值
        double a=scanner.nextDouble();
        double b=scanner.nextDouble();
        System.out.println("请输入+，-，*，/");
        //scanner.next获取用户输入的字符串
        String x=scanner.next();

        switch(x){
            case "+":
//                System.out.println(a+"+"+b+"="+(a+b));

                System.out.println(add(a,b));
            break;
            case "-":
                System.out.println(sub(a,b));
                break;
            case "*":
                System.out.println(mul(a,b));
                break;
            case "/":
                System.out.println(div(a,b));
        }



    }
    public static double add(double a,double b){
        return a+b;
    }
    public static double sub(double a,double b){
        return a-b;
    }
    public static double mul(double a,double b){
        return a*b;
    }
    public static double div(double a,double b){
        if (b==0){
            return 0;
        }else {
            return a/b;
        }

    }
}

     
        int[] num = new int[10];//声明并创建数组
           int sum=0;
       //求num和
       for (int i = 0; i < num.length; i++) {
            sum+=num[i];
        }
        System.out.println(sum);

new创建对象和数组存放在堆里，声明变量时只将变量放在栈里，并没有产生值。

public static void main(String[] args) {
       int[] arrays={1,2,3,4,5};
//        for (int a : arrays) {
//            System.out.println(a);
//   }
//           printArray(arrays);
        int[] reverse = reverse(arrays);
        System.out.print(reverse[4]);    //输出reverse的值为2，也可以用printArrays（reverse）
    }
    //通过for循环打印输出数组arrays【】的值
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]);
        }
    }
    //通过for循环进行反转，把数组arrays和reverse的值进行反转
    public static int[] reverse(int[] arrays){
        int[] result=new int[arrays.length];
        for (int i = 0,j=arrays.length-1; i < arrays.length; i++,j--) {
            result[j]=arrays[i];

        }

        return result;
    }

//2维数组，num.length是遍历有几列，num[i].length是几行
public class Demo5 {
    public static void main(String[] args) {
        //int[][] num=new int[3][4];
         int [][] num={{1,2,1,1},{2,2,2,2},{3,3,3,3}};
        for (int i = 0; i < num.length; i++) {
            for (int j = 0; j < num[i].length; j++) {
                System.out.println(num[i][j]);
            }
            System.out.println(num[i]);
        }
        System.out.println(num[0][2]);
    }

//打印输出字符
public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]);
        }
    }
    ---------------------------------------------------
    System.out.println(Arrays.toString(num));

这两个都是一样可以打印输出字符。

Arrays.sort(num);是对num数组进行排序

//冒泡排序
public static void main(String[] args) {
int[] arrays={23,4,654,32,897,1};
//int[] s=array(arrays);
        System.out.println(Arrays.toString(array(arrays)));
    }
    public static int[] array(int[] arrays){
        int m=0;
        for (int i = 0; i < arrays.length-1; i++) {
            for (int j = 0; j < arrays.length-1-i; j++) {
                if (arrays[j]>arrays[j+1]){
                    m=arrays[j];
                    arrays[j]=arrays[j+1];
                    arrays[j+1]=m;
                }
            }
        }
        return arrays;
    }

两个数进行交换要借用第三方。以及第二层循环时次数要减去本身和i的值。

public static void main(String[] args) {
//声明一个二维数组
        int[] [] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        System.out.println("输出原始数组");
        //这个循环的意思是将array1这个二维数组的值传给ints，再通过第二给循环把ints的值给anint，最后输出anint
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //sum为有效值的个数
        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 count=0;
        int [][] array2=new int[sum+1][3];
        //让array2稀疏数组的第一行变成11，11，sum的值
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;
//第一层循环是有几行，第二层是几列，如果array1[i][j]!=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");

        }
    }