java之方法和数组

小白菜00

已于 2022-08-03 09:39:25 修改

阅读量357

点赞数 1

分类专栏： Java 文章标签： java 开发语言

于 2022-07-29 16:12:58 首次发布

本文链接：https://blog.csdn.net/m0_60027772/article/details/125899798

版权

Java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

Arrays.binarySearch(升序数组，该数组的元素)

Arrays.copyOf(数组，新的长度)

Arrays.copyOfRange（数组名，下标1，下标2）

Arrays.equals(数组1，数组2)

Arrays.asList(引用类型数组)

方法

概述

含义：方法（methods）就是一段用于完成特定功能的代码片段，类似于其它语言的函数（function）

注意：方法用于定义该类或该类实例的行为特征和功能实现，方法是类和对象行为特征的抽象。方法类似于面向过程当中的函数。面向过程中，函数是最基本的单位。整个程序由一个个函数调用组成。面向对象中，整个程序的最基本单位是类，方法是从属于类和对象的

方法定义的格式

    [修饰符1 修饰符2] 返回值类型 方法名(参数列表){
        方法体;
        }

main方法

含义：程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口

    //main方法严格要求
    public static void main(String[] args) {
        System.out.println("我是程序的入口");
    }

注意：

程序中可以有多个main方法（构成了方法的重载）
默认情况下虚拟机在调用入口main方法时就是传入一个长度为0的数组

    public static void main(String[] args) {
        System.out.println("作为入口的main方法");
        System.out.println(args.length);//0
    }
    public static void main(String args) {
        System.out.println("普通main方法");
    }

关于方法注意事项

方法是对特定功能的提取，形成一个代码片段，这个代码片段就是我们所说的方法
方法和方法是并列关系，不可以在方法里面定义方法，但可以在方法里面调用方法
方法一般写在类的内部

方法的调用

普通方法的调用：对象名.方法名(参数列表);
静态方法的调用：类名.方法名(参数列表);

注意：在本类对象中调用方法，方法名可以省略

方法调用顺序

方法的调用顺序

方法的详细说明

形参：在方法声明时用于接收外界传入的数据
实参：调用方法时实际传给方法的数据
返回值：方法执行完毕后返回给调用它的环境数据，他会返回给方法的调用处
返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示为void

    public static void main(String[] args) {
        int a=5,b=8;
        int add = add(a, b);
        System.out.println(add);
    }
    public static int add(int x, int y){
        return x+y;
    }

方法内存分析

    //实现两个数交换——失败原理
    public static void main(String[] args) {
        int a=10,b=20;
        changeNum(a,b);
    }
    private static void changeNum(int n1, int n2) {
        int t;
        t=n1;
        n1=n2;
        n2=t;
    }

注意：内存分为三部分（堆、栈、方法区），先执行main方法（程序的入口），然后栈会在底部给main方法开辟一块空间也称main方法的栈帧，然后将为a变量开辟一块空间名字叫a存放10并将这块空间放入main栈帧的底部，然后将为b变量开辟一块空间名为b存放20并将此空间放入a变量的上面，然后调用changeNum方法，为changeNum开辟一块空间放在main栈帧的上面，名为changeNum栈帧（调用函数时从右往左进行实参压栈）将n2值也就是20开辟空间并将其压入changeNum的栈底取名为n2，将n1值也就是10开辟空间并将其压入n2空间的上面取名n1，然后为t开辟空间取名为t，将此空间存放n1值，将n1空间存放n2的值，将n2空间存放t的值，最终changeNum方法调用结束，changeNum栈帧销毁，main方法调用结束，main栈帧销毁。

方法的重载

方法的重载是指在一个类中定义多个同名的方法,但是每个方法的参数列表不同(也就是指参数的个数和类型不同),程序在调用方法时,可以通过传递给他们的不同个数和类型的参数来决定具体调用哪个方法.

public class Test1 {
    public static void main(String[] args) {
      method();
      method(2);
      method(2,"白米");//方法实参
    }
    private static String method() {
        System.out.println("我喜欢吃饭");
        return "其实我喜欢喝汤";
    }
    private static void method(int i) {//方法形参
        System.out.println("我喜欢吃"+i+"碗饭");
    }
    private static void method(int i,String s) {
        System.out.println("我喜欢吃"+i+"碗"+s+"饭");
    }
}

重载要求：

同一个类中的方法名相同，参数列表不同
参数的个数或类型或顺序不同
与返回值/访问修饰符无关

注意：

重载方法中参数不能耦合，eg：success（String a）和success（Object a）如果里面都传String类型的数据，那么会以最短路径原则进而直接调用String类型为参数的方法
对于数值类型的方法重载（不同类型）优先级为：byte,short,char-int-long-float-double

    public static void main(String[] args) {
        add(5);
    }
    private static void add(float i) {
        System.out.println("float");
    }
    private static void add(long i) {
        System.out.println("long");
    }

可变参数

含义：提供了一个方法，使参数的个数是可变的

语法：数据类型...参数名

作用：解决了部分方法的重载问题

    public static void main(String[] args) {
        method1(10);
        method1(20,30);
        method1();
        method1(new int[]{11,22,33});
    }
    //可变参数的写法
    private static void method1(int...num) {
        if(num.length>0){
            System.out.println(num[0]);
        }else{
            System.out.println("我没有参数");
        }
    }

注意：

可变参数的参数个数可变，但是类型不可变
方法内部对可变参数的处理和对数组的处理一样
可变参数和其他参数一起作为形参的时候，可变参数一定要放到最后（前面数据为其他参数，之后的所有数据为可变参数）

数组

前言

含义：数组是相同类型数据的有序集合

因为变量没有办法储存多个值，所以才将数组的地址值传给变量以示数组

注意：

数组Array，标志是[ ] ,用于储存多个相同类型数据的集合,其属于引用数据类型
想要获取数组中的元素值，可以通过脚标（下标）来获取
数组下标是从0开始的,下标的最大值是数组的长度减1
数组的地址是连续的
数组一旦创建，长度不可改变
数组可以容纳基本数据类型，也能容纳引用数据类型，里面的数据类型都是一致的
数组本身就是对象，数组中的每个元素相当于对象的成员变量

创建数组

静态初始化：定义数组的同时就为数组元素分配空间并赋值

动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行

        //动态初始化
        int[] a = new int[5];
        //给数组赋值，如果数组多出的长度用0填补，超出的报错
        a[0] = 1;
        a[1] = 2;
        int[] i;
        i=new int[5];
        //静态初始化
        int[] b = new int[]{1, 2, 3, 4, 5};
        int c[] = new int[]{1, 2, 3, 4, 5};
        int[] d = {1, 2, 3, 4, 5};
        int[] e;
        e=new int[]{1,2,3};

注意：动态初始化的数组有默认值，具体值类型要看是什么类型的数组

创建数组过程分析

数组结构

eg： int[] a = new int[5];

在堆内存中开辟连续的空间,用来存放数据,长度是5
给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
数组完成初始化会分配一个唯一的地址值
把唯一的地址值交给引用类型的变量a去保存

数组的长度

数组的长度用 length属性来表示,数组一旦创建，长度不可改变
数组的长度允许为0

数组的遍历

遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素

        //遍历数组
        int[] a={1,2,3,4,5};
        for (int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }

创建随机数组

  public static void main(String[] args) {
        //1.创建数组--动态
        int[]a=new int[10];
        //2.遍历数组,给数组中的每个元素赋值
        for(int i=0;i<a.length;i++){
            //100是自定义的数据,表示生成的随机整数的范围是[0,100)
            a[i]=new Random().nextInt(100);
            //a[i] = new Random().nextInt(100)+1;//取值范围前后都+1-->[1,101)
        }
        //3.使用数组的工具类查看数组中的元素
        System.out.println(Arrays.toString(a));
    }

数组工具类Arrays

使用时需导包：import java.util.Arrays;

Arrays.toString(数组)

把数组里的数据,用逗号连接成一个字符串[值1,值2]

返回值：返回指定数组内容的字符串表示

原数组不变

public static void main(String[] args) {
        char[] s={'h','e','l','l','o'};
        System.out.println(s);
        //s是引用类型的变量，保存的是数组的地址值，由于JAVA对char类型做了底层处理，所以char[]可以直接打印具体内容，
        // 但是除了char类型以外其他任何类型想要查看数组中的元素都需要使用数组工具类Arrays.toString(数组名)
        int[] i={1,5,3,8,4};
        System.out.println(Arrays.toString(i));
}

Arrays.sort(数组)

对数组进行升序排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高，对引用类型数组,使用的是优化后的合并排序算法

返回值：无

原数组被升序排序

public static void main(String[] args) {
        int[] a={1,3,6,2,4,5};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6]
}

Arrays.binarySearch(升序数组，该数组的元素)

使用前提：一定要查看的是一个升序数组

返回值：指定数组中指定的元素所对应的索引

原数组不变

        int[] i={1,5,3,8,4};
        Arrays.sort(i);
        System.out.println(Arrays.toString(i));
        int i1 = Arrays.binarySearch(i, 5);
        System.out.println(i1);

Arrays.copyOf(数组，新的长度)

把数组赋值成一个指定长度的新数组
新数组的长度大于原数组, 相当于复制,并增加位置（多出来的部分用0代替）
新数组的长度小于原数组, 相当于截取一部分数据

返回值：指定的新数组

原数组不变

        //1
        int[] a={1,3,6,2,4,5};
        int[] a1 = Arrays.copyOf(a, 10);
        System.out.println(Arrays.toString(a1));//[1, 3, 6, 2, 4, 5, 0, 0, 0, 0]
        //2
        int[] a2 = Arrays.copyOf(a, 3);
        System.out.println(Arrays.toString(a2));//[1, 3, 6]

Arrays.copyOfRange（数组名，下标1，下标2）

指定首尾截取数组中的元素
[下标1，下标2）
复制之后原数组还在

返回值：指定好的新数组

原数组不变

        int[] a={1,3,6,2,4,5};
        int[] a1 = Arrays.copyOfRange(a, 2, 4);
        System.out.println(Arrays.toString(a1));//[6, 2]

Arrays.equals(数组1，数组2)

作用：比较两个数组的值是否一样

返回值：如果值一样返回true，否则返回false

        int[] i={9,5,4,2,1};
        int[] i1={9,5,4,2,1};
        boolean equals = Arrays.equals(i, i1);
        System.out.println(equals);//true
        System.out.println(i==i1);//比较的是两侧的地址值结果为false

Arrays.asList(引用类型数组)

作用：将数组转为List集合

返回值：对应数组元素的List集合

        Integer[] i = new Integer[]{1,4,9};
        List<Integer> list = Arrays.asList(i);
        System.out.println(list);

关于System.arraycopy

System.arraycopy(原数组名, 复制起始位置,目标数组名,粘贴起始位置,复制多少元素);

    public static void main(String[] args) {
        int[] b=new int[6];
        int[] a={1,2,3,4,4};
        System.arraycopy(a, 0,b,1,3);
        System.out.println(Arrays.toString(b));//[0, 1, 2, 3, 0, 0]
    }

二维数组

概述

定义：存放数组的数组，也就是说数组里存的还是数组的数据形式

二维数组图示

注意：

一维数组与二维数组的地址都是连续的
二维数组是一维数组的数组

创建二维数组过程

eg：int[][] a = {{3,5},{7,9},{1,2}};

创建外部数组,长度是3
给每个外部数组的位置创建内部数组,每个内部数组的长度是2
给每个内部数组进行数据初始化
二维数组生成唯一的地址值
把地址值交给引用类型变量a来保存

二维数组的写法

        //动态写法
        //写法正确，确定行数为2行每行都有一个数组;所有行为1个大数组，数组值可以为空，当然，后面的括号也可有值
        int[][] a=new int[2][];
        int[] i1={1,2};
        int[] i2={3,5,6};
        a[0]=i1;    a[1]=i2;
        System.out.println(a[1][2]);
        
        //静态写法
        int[][] a1={{1,2},{2,3,4},{3,4}};
        int[][] a2=new int[][]{{1,2,3},{2,3},{3,4}};//注意：int后面两[]不能写值

二维数组的遍历

    //普通for循环
    public static void main(String[] args) {
        int[][] a={{1,2},{2,3,4},{3,4}};
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a[i].length;j++){
                System.out.println(a[i][j]);
            }
        }
    }

    //增强for循环
    public static void main(String[] args) {
        int[][] a={{1,2},{2,3,4},{3,4}};
        for (int[] b:a){
            for (int c:b){
                System.out.println(c);
            }
        }
    }

小白菜00

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java之方法和数组

方法（methods）就是一段用于完成特定功能的代码片段，类似于其它语言的函数（function）方法用于定义该类或该类实例的行为特征和功能实现，方法是类和对象行为特征的抽象。方法类似于面向过程当中的函数。面向过程中，函数是最基本的单位。整个程序由一个个函数调用组成。面向对象中，整个程序的最基本单位是类，方法是从属于类和对象的[修饰符1修饰符2]返回值类型方法名(参数列表){方法体;}数组是相同类型数据的有序集合因为变量没有办法储存多个值，所以才将数组的地址值传给变量以示数组相同类型。.........
复制链接

扫一扫