方法&数组

已于 2022-03-26 15:25:22 修改
阅读量271 收藏
点赞数
文章标签： java
于 2022-03-24 13:11:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wly2333777/article/details/123708467
版权

方法&数组

方法

  • 语句的集合，在一起执行一个功能
    1. 解决一类问题的步骤的有序组合
    2. 包含在类或对象中
    3. 在程序中被创建，其他地方被引用
  • 设计原则
    1. 功能块
    2. 设计时一个方法只有一个功能，原子性

方法的定义及调用

定义

方法包含一个方法头和方法体，是一段用来完成特定功能的代码片段

修饰符  返回值类型 方法名（参数类型 参数名）{
    方法体
        ...
        ...
        ...
      return 返回值;//终止方法
}
  • 修饰符：可选的，告诉编译器如何调用该方法。定义了该方法的访问类型
  • 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需操作没有返回值，这种情况下，returnValueType是关键字void
  • 方法名：方法的实际名称
  • 参数类型：参数像一个占位符。当方法被调用时，传递参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数个数。参数是可选的，方法可以不包含参数。
    1. 形式参数：在方法被调用时用于接受外界输入的数据
    2. 实参：调用方法时实际传给方法的数据
  • 方法体：包含具体语句，定义该方法功能
调用
  • 调用方法：对象名.方法名(实参列表)
  • 当返回为一个值，方法通常调用这个值
  • 返回void，方法调用一定是条语句
  • 值传递（JAVA）和引用传递

方法重载

  • 重载就是在一个类中，有相同的函数名称，但形参不同的函数
  • 方法重载的规则：
    1. 方法名称必须相同
    2. 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同）
    3. 方法的返回类型可以相同也可以不相同
    4. 仅仅返回类型不同不足以成为方法的重载
  • 实现理论：方法名称相同时，编译器会根据调用方法的参数个数、参数类型等逐个进行匹配失败，如果匹配失败，编译器会报错。

命令行传参

通过命令行进行编译和执行，传递一些参数

可变参数

也叫不定项参数

  • 在方法声明中，在指定参数类型后加一个省略号（…）

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

  • public class Demo{
    public static void main(String[] args){
        Demo demo=new Demo();
        demo.test(1);
    }
    public void test(int... i){//可变参数
        System.out.println(i[0]);
    }
}

递归

A方法自己调用自己

递归结构

A方法自己调用自己

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

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

    public class Demo{
    public static void main(String[] args) {
        System.out.print(f(2));
        }
        public static int f(int n){
        if (n==1){
          return 1;  //不调用方法，边界条件
        }else{
            return n*f(n-1);
        }
        }
    }

数组

数组概述

  • 相同类型数据的集合

  • 按照一定的先后次序

  • 可以通过下标来访问

  • 特点

    1. 一旦被创建大小不可改变
    2. 数组内所有元素类型相同
    3. 可以是任意数据类型
    4. 数组可以看成对象，数组中的每个元素相当于该对象的成员变量
    5. 数组对象本身是在堆中

  • 数组边界

    数组下标越界：ArrayIndexOutOfBoundsExCeption

数组声明、创建、初始化

声明数组
  • int[] nums;//dataType[] arrayRefVar;

  • int nums[];//dataType arrayRefVar[];
创建数组
  • int[] sums=new int[10]//存10个数组8
//dataType[] arrayRefVar=new dateType(arraySize);
获取数组长度
arrays.length
数组初始化
  • //静态初始化，创建＋赋值
int[] a={1,2,3,4,5}
//创建类public class Many(){}
Man[] mans={new Man(),new Man()}//引用类

  • int[] b=new int[10];
b[0]=10;//动态初始化
//包含默认初始化

内存分析

  • 堆
    1. 存放new的对象和数组
    2. 可以被所有线程共享，不会存放别的对象引用
  • 栈
    1. 存放基本变量类型（会包含这个基本类型的具体数值）
    2. 引用对象的变量（会存放这个引用在堆里面的具体地址）
  • 方法区
    1. 可以被所有线程共享
    2. 包含了所有class和static共享

数组使用

  • 基本用法

    public class Demo{
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        for (int i = 0; i <arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("所有元素的和");
        int sum=0;
        for (int i = 0; i <arrays.length ; i++) {
            sum+=arrays[i];
        }
        System.out.println(sum);
        System.out.println("查找最大元素");
        int max=arrays[0];
        for (int i = 1; i <arrays.length ; i++) {
            if (max<arrays[i]){
                max=arrays[i];
            }else {
                System.out.println(max);
            }
        }
        System.out.println(max);
            }
        }

  • 进阶用法

    数组名 for（增强型for循环，没有下标）

    
public class Demo{
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        for (int array : arrays) {//增强型for循环
            System.out.println(array);
        }
        printArray(arrays);
        //反转输出
        int[] reverse=reverse(arrays);
        printArray(reverse);
    }
    public static void printArray(int[] arrays){//作为方法入参
        for (int i = 0; i <arrays.length ; i++) {
            System.out.print(arrays[i]+" "+"\n");
        }
    }
    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;
    }
        }

多维数组

public class Demo{
    public static void main(String[] args) {
        int[][] array={{1,1},{1,2},{1,3},{1,4}};
//        printArray(array.length);
//        System.out.print(array[0].length+"  ");
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                System.out.print(array[i][j]+" ");
            }
        }
    }
    public static void printArray(int[] arrays){//作为方法入参
        for (int i = 0; i <arrays.length ; i++) {
            for (int j = 0; j <arrays.length ; j++) {
                System.out.print(arrays[i]+" ");
            }
        }
    }
}

Arrays类

工具类，直接调用

查看JDK帮助文档

Arrays.toString()；

import java.util.Arrays;
public class Demo{
    public static void main(String[] args) {
        int[] a={1,2,3,21,2,232,323213,2};
        Arrays.sort(a);//排序
        Arrays.fill(a,2,4,0);//填充，将0填充到2-4之间
        System.out.print(Arrays.toString(a));
    }
}

冒泡排序

共有8大排序

时间复杂度O(n^2)

import java.util.Arrays;

/*
 * 冒泡排序
 * 比较数组中两个相邻元素并交换位置
 * 每一次比较都会产生一个最大或最小的数字
 * 下一轮可以少一次排序*/
public class Demo{
    public static void main(String[] args) {
        int[] a={1,32,324,24,2,312,321,3232,456,67};
//        Arrays.sort(a);
        int[] sort=sort(a);//调用方法
        System.out.print(Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        int temp=0;
        //外层，判断要走多少次
        boolean flag=false;
        for (int i = 0; i < array.length-1; i++) {
            //比较两个数，如果第一个数大于第二个数则交换位置
            for (int j = 0; j <array.length-1-i ; j++) {
                if (array[j+1]>array[j]){//后一个比前一个大交换位置
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=true;
                }
            }
            if (flag==true){
                break;
            }
        }
        return array;
    }
}

稀疏数组

数组中大部分为0，或为同一数组时，可以使用稀疏数组保存

稀疏数组的处理方式：

  • 记录数组有几行几列，有多少个不同值

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

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S55yG4F5-1648098577439)(D:\笔记\photo\IMG_1277(20220323-190747)].PNG)

  • package com.wly.Dome;

import java.util.Arrays;
public class Demo {
    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.print("\n");
        }
        //转换为稀疏数组
        int sum=0;
        for (int i = 0; i <array1.length ; i++) { //获取有效值个数
            for (int j = 0; j <array1.length ; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
            }
        System.out.println("有效值个数"+sum);
        int[][] array2=new int[sum+1][3];
        array2[0][0]=array1.length;
        array2[0][1]=array1.length;
        array2[0][2]=sum;
        //遍历二维数组，将值存放在稀疏数组中
        int count=0;
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array1.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++) {
            for (int j = 0; j <array2.length ; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }
        //还原数组
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i <array2.length ; i++) {
            for (int j = 0; j <array2.length ; j++) {
                array3[array2[i][0]][array2[i][1]]=array2[i][2];
            }
        }
        System.out.println("还原数组：");
        for (int i = 0; i <array3.length ; i++) {
            for (int j = 0; j <array3.length ; j++) {
                System.out.print(array3[i][j]+"\t");
            }
            System.out.println();
        }
        }
    }

快捷键

for (String arg : args) {
}//1、输入iter按Tab

for (int i = 0; i < args.length; i++) {
    String arg = args[i];
}//2、输入itar按Tab

for (int i = 0; i < ; i++) {
}//3、输入fori按Tab

for (int i = 0; i < list.size(); i++) {
    Object o =  list.get(i);
}//4、输入itli按Tab

快捷键

for (String arg : args) {
}//1、输入iter按Tab

for (int i = 0; i < args.length; i++) {
    String arg = args[i];
}//2、输入itar按Tab

for (int i = 0; i < ; i++) {
}//3、输入fori按Tab

for (int i = 0; i < list.size(); i++) {
    Object o =  list.get(i);
}//4、输入itli按Tab
n . x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值