2.Java方法的应用和数组

Java方法的应用

1.方法的定义与作用

指的是封装了能够实现某个功能的代码块，实现方法的复用，方便维护和修改

2.方法声明与定义的格式

无返回值，无参数：一般用于加载驱动程序，或进行初始化等

无返回值，有参数：一般用于用户的输入并进行初始化等

有返回值，无参数：一般提供给外部调用

有返回值，有参数：（使用频率高）接收用户输入同时提供外部调用并进行处理

案例解析

import com.sun.org.apache.bcel.internal.generic.RETURN;

import java.util.Scanner;

/**
 * @公共的类务必要有一个唯一同名的源文件
 */
public class MyMethod {
    //主方法，用于启动程序
    //用于调用自定义方法
    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
//        go2(2, 3, 4);//实参
//        go3();
        do1();
        sc.close();
    }
    //无返回值无参数，一般用于加载驱动或初始化
    //public访问控制符
    //static状态修饰符，此处为静态方法
    //viod无返回值
    //go1方法名

    public static void go1() {
        System.out.println();
    }

    //有返回值无参数，接收外部的传值
    //通过传参来求出任意三个数的比较
    public static void go2(int a, int b, int c) {//形参
        if (a > b && a > c) {
            System.out.println("最大值是" + a);
        } else if (b > a && b > c) {
            System.out.println("最大值是" + b);
        } else {
            System.out.println("最大值是" + c);
        }
    }

    //有返回值无参数，又称函数，返回值给外部调用并进行处理
    //返回值指的是方法计算完成后，给外部调用后的一个结果，方便之后再加工
    //返回值：基本八大类型或引用类型
    public static int go3() {

        return 9;
    }

    //有返回值有参数，又称函数
    //double计算小数是不精确的
    public static double go4(double o) {


        return 0.3;
    }

    public static void do1() {
        int  m = 10;
        int ab = 0, cd = 0, da = 0;
        for (int a=0; a < m; a++) {
            for (int b = 0; b < m; b++) {
                for (int c = 0; c < m; c++) {
                    for (int d = 0; d < m; d++) {
                        ab = (a * 10) + b;
                        cd = (c * 10) + d;
                        da = (d * 10) + a;
                        if (ab + cd == da && ab > 10 && cd > 10) {
                            System.out.println(ab + "+" + cd + "=" + da);
                        }
                    }
                }
            }
        }
    }
}

二，Java的数组应用

批量存取数据类型相同的数据容器,方便数据管理

数组的分类:一维数组与多维数组

一维数组:只有一行数据的数组

多维数组:有多行与多列数据组成

2.2数组的概念

数组元素:存储的每个数据

元素的下标(索引):元素在数组中存储的位置号,结束为数组的长度-1

数组的长度length:指的是数组中存储元素的最大的个数

数组的最大的下标:等于数组长度-1

数组的第一个下标为0

数组元素的赋值与取值: 都是通过数组名(下标)来存取

数组存取的格式:

一维数组 :12 13 14 15

二维数组:2 3 5 7 9 1 (可以只存单行)

​ 3 2 5 3 1 7

​ 3 2 1 4 6 8

2.3一维数组的应用

创建数组(new数组)有两种格式:动态方式与静态方式

标准格式:类型[] 数组名 = new int[长度];

数组的存储空间:存地址(栈), 存内容(堆)

数组名.sort();//数组的升序排列

案例解析:

import java.security.PublicKey;

/**
 * 数组的应用
 */
public class MyArray {
    public static void main(String[] args) {
        go1();
    }
    //一维数组的使用：动态方式创建数组
    public static void go1() {
        //创建了长度为5的整型一维数组
        //arr数组名（对象，变量）同时代表了数组在栈中的地址
        //如果输入数组名，则显示地址
        //所有元素都有默认值，为0
        int[] arr = new int[5];
        System.out.println(arr);
        //给数组重新赋值
        arr[0] = 90;
        arr[1] = 30;
        arr[2] = 20;
        arr[3] = 70;
        arr[4] = 10;
        //数组下标越界
       // arr[5] = 80;
        //数组元素取值
        int temp = arr[3] + 3;
        System.out.println(temp);
        System.out.println("数组的长度"+ arr.length);
        System.out.println("数组的最后元素" + arr[arr.length-1]);
        //数组的遍历：显示所有元素，常用for循环来实现
        //标准for
        for (int i = 0;i=0;i--){
            System.out.print(arr[i] + " ");
        }
    }
    //静态方式，直接赋值创建数组
    public static void go2(){
        //创建数组
        int[] arr = {1,3 ,4, 5, 7};
        //创建数组
        int[] a;
        a = new int[] {1, 4,2 ,5, 9};
        //重新赋值
        a[0] = 10;
    }
}

数组的应用:排序与查找等

插入排序：从第二个元素开始，依次取值跟前面所有元素比较，然后排序

希尔排序：是插入排序的升级，分组+插入排序

/**
 * 数组的排序与查找
 */
public class MyApp {
    public static void main(String[] args) {
        int[] arr ={2, 1, 3, 4, 8};
//        bubbleSoret(arr);
//        disp(arr);
        selectSort(arr);
        disp(arr);
        //在排序过的的数组中查找元素4
        int temp = bingaryFind(4,arr);
        System.out.println("\n");
        System.out.println(arr[temp]);

    }
    //1.冒泡排序：从第一元素开始，元素两两比较
    public static void bubbleSoret(int[] arr){
        //控制轮数
        for (int i= 0;iarr[j]){
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    //希尔排序：将数组分为诺干序列，对序列排序，之后缩小序列间距然后在排序，一直到间距为1
    //3.二分查找：（数据量大时使用）从已经从小到大排过序的数组中查找指定元素
    //二分查找的前提是排好序的数据
    //最小下标加最大下标/2，目标元素大于中间元素，中间元素下标+1+最大下标/2，比较目标元素与中间下标元素，知道找到目标元素
    public static int bingaryFind(int num,int [] arr){
        int  start = 0;
        int end = arr.length-1;
        int temp = -1;
        while (start<=end){
            int middle = (start+end)>>>1;
            if (num == arr[middle]){
                temp = middle;
                break;
            }else if (num>arr[middle]){
                start=middle+1;
            }else {
                end = middle-1;
            }
        }

        return temp;
    }

}

2.4二维数组

以行与列保存类型相同的数据

二维数组相当于是由多行一维数组组成

相关概念:

行的长度:二维数组名.length

每一行的列数:数组名[行下标].length

二维数组中元素表示:数组名[行下标] [列下标]

比如:int[][] arr = new int[3] [4]

//第二行的第三个元素

arr[1] [2]

三,Arrays工具的使用

Arrays数组工具,在Java.utils包中,可以实现数组的排序与动态扩容与缩容

public static void paly3(int[] arr){
        //默认从小到大排序
        Arrays.sort(arr);
        disp(arr);
        //2.数组动态扩容
        int[] a = new int[3];
        a[2] = 20;
        //数组扩容，长度为4
        a = Arrays.copyOf(a,a.length+1);
        a[a.length-1]=99;
        System.out.println( "a.length-1是"+ a[a.length-1]);
    }

截取字符串:

split()+正则表达式
不常用，不过在某些特定场合特别好用。
格式:
字符串.split(“指定分隔符”); -返回的是一个数组

string str ="good, good, study, day,day,up";
string[] split = str.split(",");
for (String s:
split) {
System. out. println(s);
}

substring()
这个比较常用的一个方法。
此方法有两种形式:

1
substring(int beginIndex); //提取从索引位置开始至结尾处的字符串部分
2
substring(int beginIndex, int endIndex); //提取beginIndex开始到endIndex的字符串部分