Java学习七之方法和数组

_不知名小白

已于 2022-08-09 08:41:30 修改

阅读量188

点赞数

分类专栏： Java学习 Java 数据结构与算法文章标签： java 学习 servlet

于 2022-07-17 20:52:09 首次发布

本文链接：https://blog.csdn.net/weixin_45603472/article/details/125836418

版权

Java学习同时被 3 个专栏收录

22 篇文章 1 订阅

订阅专栏

Java

17 篇文章 0 订阅

订阅专栏

数据结构与算法

7 篇文章 0 订阅

订阅专栏

一、方法

1.什么是方法？

方法就是method.
方法实际上就是一块代码.
方法可以有参数，可以有返回值，也可以被调用.
方法就是一种代码复用的方式.
方法是类的重要组成部分.

2.语法：

修饰符返回值类型方法名(参数列表){
方法体
}
main方法，是Java程序执行的入口方法

1.修饰符：用来修饰方法的，限定方法的适用范围和使用方式

       权限修饰符：public公共的,private 私有的,protected保护的,默认的(啥也不写)
       static :静态的
       abstract ：抽象的
       final：最终的
static、abstract、final会在后面的文章中介绍

2.返回值类型

       方法执行完成后，需要向方法的调用者返回一个结果，这个结果的数据类型就是返回值类型。
       返回值类型可以有一下几种:
       1）void （没有返回值）
       2）8种基本数据类型
       方法的返回值必须是指定类型的，只要可以自动转换就可以
       3）3种引用类型：数组接口类

如果方法返回值类型是void，在方法中可以使用return；结束方法。 return后不可以加任何值
如果方法指定返回值类型，在方法的任意一条通路上，都要使用return 提供一个返回值。

3.参数列表：

       方法在调用时可以传递参数，作为方法处理的输入数据。
       1) 方法可以没有参数，无参方法
       2) 方法可以传递多个参数，多个参数之间需要使用’,'进行分隔
       3)方法的参数需要指定数据类型
       4)方法的参数可以是可变参数

 public static int min(int... args) {
        //int... 代表min方法可以传递多个int类型的参数
        //这些参数都会被放到args中，组成一个数组
        int min=args[0];
        for(int i=0;i<args.length;i++){
            if(args[i]<min){
                min=args[i];
            }
        }   
        return  min;
    }

3.方法的调用

语法：
方法(参数值);

1)方法在调用时，参数必须匹配(参数的个数，参数的数据类型，参数的顺序)
2)可变参数的方法在调用时，可以传递0个参数，也可以传递多个参数
3)如果方法有返回值，可以使用相应类型的变量接收方法的返回值

形参和实参:
形参：形式参数，方法在定义时参数列表中的定义的参数。形参的方法中就像一个变量
实参：实际参数，方法在调用时所传递的具体值

在方法调用时，实参的数据类型必须与形参相匹配

递归调用
求n的阶乘 n！=1 * 2 * 3 * ··· * (n-1) * n
n!=(n-1)! * n

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

递归在实现一些算法时更加直观，容易理解
递归调用可以转换成循环

4.方法的重载

在一个类中，如果出现了方法名相同，但是参数列表不同的方法。

参数列表:

参数的数量不一样
参数的数据类型不一样
参数的顺序不一样

不构成重载
返回值类型不同，不能构成重载
参数名不同，不能构成重载

重载方法的调用：根据实参的数据类型，来寻找最为匹配的方法。

二、数组

程序=算法+数据结构
算法：解决程序的流程步骤（顺序、分支、循环）
数据结构：将数据按照某种特定的结构来存储

设计良好的数据结构会导致良好的算法。

数组是最简单的数据结构。

1.什么是数组

数组：存放同一种类型数据的集合，在内存里面是开辟一块连续的区域。

数组是一种引用类型
Java中数组被被限定为对象，他们一般都会因为记录长度而需要额外的内存，一个原始数据类型的数组一般需要24字节的头信息(16个自己的对象开销，4字节用于保存长度以及4个填充字节)再加上保存值所需的内存

在Java中数组是一块连续的内存空间，所以在访问数组元素时，可以使用下标
数组一旦创建，长度就是固定的

2.定义数组

数据类型[] 数组名; 推荐）或者数据类型数组名[];

数组定义实际就是一个变量的定义，也需要对数组进行初始化操作

int num = 3;
int[] array = new int[4];
1、存放整数类型的数组
2、长度是4
3、只能存放int类型

3.数组的初始化

为数组分配内存，指定数组长度(元素的个数)
根据元素的数据类型和数组长度决定分配多大的内存。
例如：int型数组，要保存5个元素——>分配4字节 * 5 = 20个字节内存再加上数组自身头信息开销的24个字节
初始化数组中的每一个元素
       数组初始化的三种方式
       1）数组名 = new 数据类型[长度];
              a)再JVM的堆内存中，开辟出指定长度的连续的一块内存空间。
              b)为数组中的每一个元素设置成类0的值
              byte,short,int,long,float,double 直接初始化成0
              char 初始化成空字符
              boolean 初始化成false
              引用类型初始化成null
       2)数组名 = new 数据类型[]{元素1.元素2,…,元素n};
              a)在JVM的堆内存中，开辟出{}中元素数量的连续的一块内存空间
              b)将{}中的元素一次放到数组的每一个元素中
       3)数据类型[] 数组名 = {元素1，元素2,…,元素n};
              过程与2)一样
1) 2)可以在数组定义时使用，也可以数组定义之后使用
3)只能在定义数组时使用

数组的操作

1.访问数组元素
数组名[下标];

下标:元素在数组中的位置
取值:从0开始~数组的长度-1

如何判断数组的长度： 数组名.length 获取数组的长度
如果下标超出了取值范围，这时会报错：
java.lang.Array Index OutOf Bounds Exception: 4
数组下标越界

@Test
public void test3() {
    int[] array = new int[4];
    array[0] = 24;
    array[1] = 23;
    array[2] = 3;
    array[3] = 4;
    for (int i = 0; i <= array.length; i++) {
        System.out.println(array[i]);
    }
}

在这里插入图片描述

在这里插入图片描述
2.遍历
把集合中的每一个元素依次取出
1）使用循环迭代生成元素的下标
2）使用增强for循环(也叫foreach)
语法：
for(数量：集合){
循环体
}

a)从集合中取出一个元素，放在变量中
b)如果能取出，进入循环体执行，循环体内执行完成后，回到a)
c)如果取不出，结束循环

 @Test
    public void test111(){
      int[] array=new int[]{1,2,9,5,8,6,5};
       for (int arr : array) {
           System.out.println(arr);
       }

   }

数组最重要操作就是遍历

基于遍历可以对数组进行：
1）求和，求平均值
2）求最大最小值
3）查找数组中的元素

三、数组运用练习

1、回文数

题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
char[] array = {‘a’ , ‘b’, ‘c’, ‘b’ , ‘a’};
在这里插入图片描述
方法一：
i=0 j=array.length-1
i=1 j=array.length-2
i+j=array.length-1
j=array.length-i-1
array.length-i-1

 @Test
    public void test88() {
        // char[] array = {'a' , 'b', 'c', 'b' , 'a'};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        String str = scanner.next();// "abcba"
        System.out.println(str);
        char[] array = str.toCharArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        boolean isHuiWen = true;
        for (int i = 0; i < array.length; i++) {
            if (array[i] != array[array.length - i - 1]) {
                isHuiWen = false;
                break;
            }
        }

        if (isHuiWen) {
            System.out.println("是回文");
        } else {
            System.out.println("不是回文");
        }


    }

方法二

@Test
public void test9() {
    Scanner scanner = new Scanner(System.in);
    int num = scanner.nextInt();
    if (judgePalindrome(num)) {
        System.out.println(num + "是回文数");
    } else {
        System.out.println(num + "不是回文数");
    }
}

//    判断回文数 palindrome  
public boolean judgePalindrome(int num) {
   boolean isPalindrome = false;
    if (num < 0 ||( num % 10 == 0 && num != 0)) {
        return isPalindrome;
    } 
    int temp=num;
    int newNum = 0;
    //反转数
    while (temp > 0) {
        newNum *= 10;
        newNum += temp % 10;
        temp/= 10;
    }
    if (num == newNum) {
        isPalindrome = true;
    }
    
    return isPalindrome;
}

方法三

public boolean judgePalindrome2(int num) {
    boolean isPalindrome = true;
    if (num < 0 || (num % 10 == 0 && num != 0)) {
        isPalindrome=false;
        return isPalindrome;
    }
    String str = String.valueOf(num);
    int front = 0;
    int behind = str.length() - 1;
    while (front < behind) {
        if (str.charAt(front) == str.charAt(behind)) {
            front++;
            behind--;
        } else {
            isPalindrome = false;
            return isPalindrome;
        }
    }
    return isPalindrome;
}

2.输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

@Test
public void test10() {
    // char[] array = {'a' , 'b', 'c', 'b' , 'a'};
    Scanner scanner = new Scanner(System.in);
    String str = scanner.nextLine();// "abcba"
    System.out.println(str);
    int englishLetterCount = 0;
    int spaceCount = 0;
    int numberCount = 0;
    int otherLetterCount = 0;
    char[] array = str.toCharArray();
    for (int i = 0; i < array.length; i++) {
        if ((array[i] >= 'a' && array[i] <= 'z') || (array[i] >= 'A' && array[i] <= 'Z')) {
            englishLetterCount++;
        } else if (array[i] == ' ') {
            spaceCount++;
        } else if (array[i] >= '0' && array[i] <= '9') {
            numberCount++;
        } else {
            otherLetterCount++;
        }
    }
    System.out.println("英文字母个数：" + englishLetterCount + "  "
            + "空格个数：" + spaceCount + " " + "数字个数:" + numberCount + " "
            + "其它字符个数:" + otherLetterCount
    );
}

也可以用 toCharArray()方法

 @Test
    public void test38() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        String str = scanner.nextLine();// "abcba"
        System.out.println(str);
        char[] array = str.toCharArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        int latterCount = 0;
        int spaceCount = 0;
        int digitCount = 0;
        int otherCount = 0;
        for (char ch : array) {
            if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
                latterCount++;
            } else if (ch == ' ') {// ""  ''
                spaceCount++;
            } else if (ch >= '0' && ch <= '9') {
                digitCount++;
            } else {
                otherCount++;
            }
        }
        System.out.println("latterCount:" + latterCount);
        System.out.println("spaceCount:" + spaceCount);
        System.out.println("digitCount:" + digitCount);
        System.out.println("otherCount:" + otherCount);
    }

3.输入一组学生的成绩，使用数组，然后计算他们的平均值.

@Test
public void test8() {
    Scanner scanner = new Scanner(System.in);
    int[] scores = new int[3];
    int AVGScore = 0;
    int totalScore = 0;
    System.out.println("请依次输入学生们的分数");
    for (int i = 0; i < scores.length; i++) {
        scores[i] = scanner.nextInt();
    }
    for (int i = 0; i < scores.length; i++) {
        totalScore += scores[i];
    }
    AVGScore = totalScore / scores.length;
    System.out.println("平均分" + AVGScore);

}

4.求出数组中0-9分别出现的次数

int[] scores={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9};

@Test
public void test6(){
    int[] scores={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9};
    int[] counts=new int[10];
    for (int i=0;i<scores.length;i++){
      counts[scores[i]]++;
    }
    for (int i = 0; i < counts.length; i++) {
        System.out.println(counts[i]);
    }
}

5.求出下面数组中的奇数个数和偶数个数。

int[] scores={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9};

  @Test
    public void test7(){
        int[] scores={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9};
//        奇数数量
        int oddNumberCount = 0;
//        偶数数量
        int evenNmberCount = 0;
        for (int i = 0; i < scores.length; i++) {
            if(scores[i]%2==0){
                evenNmberCount++;
            }  else {
                oddNumberCount++;
            }
        }
        System.out.println("奇数数量："+oddNumberCount+"   "+"偶数数量:"+evenNmberCount);
    }
}