一起重新开始学大数据-java篇-DAY07-数组2和方法

最新推荐文章于 2021-09-20 15:07:54 发布

你的动作太慢了！

最新推荐文章于 2021-09-20 15:07:54 发布

阅读量143

点赞数 1

分类专栏：大数据从零开始学习文章标签： java 大数据

本文链接：https://blog.csdn.net/tiand7/article/details/118422282

版权

大数据从零开始学习专栏收录该内容

66 篇文章 12 订阅

订阅专栏

本文介绍了Java中数组的定义、访问、二分查找和动态、静态初始化。详细讲解了如何进行数组的增加、删除操作，并提供了具体案例。此外，还探讨了方法的调用和注意事项，包括方法的重载。最后，简要提到了二维数组的定义和访问方式，以及递归的概念。

摘要由CSDN通过智能技术生成

一起重新开始学大数据-java篇

DAY07-数组2和方法

学习内容：

1. 数组格式、访问、二分查找和数组的增加、删除
2. 方法的调用和各种注意事项

数组知识点回顾：

数组:

存储多个数据类型相同的存储模型

定义:
格式1:直接创建数组

	数据类型[] 变量名;

格式2:先创建基本数据类型,在创建数组

	数据类型 变量名[];

注意:
建议使用格式1

动态初始化:手动指定长度,系统分配默认值(int默认值0,String为null)

格式:
	数据类型[] 变量名=new int[长度];

静态初始化:手动指定元素,系统分配默认长度

格式:
	数据类型[] 变量名=new int[]{元素1,元素2...元素n};
简化格式:
     数据类型[] 变量名={元素1,元素2...元素n};
注意:
	简化格式写法不可分割内存:

栈:

	局部变量,变量名,使用完成后立即删除

堆:

	new出来的东西
	会有地址值

在这里插入图片描述

数组的访问:

1.访问数组
	格式:数组名称

2.访问数组中的元素

	格式:

		数组名称[索引/下标/index]

索引:数组中元素的标识(行号)

特点:
	1.逐一递增+1
	2.从0开始
	3.连续的

//遍历的通用格式:
	for(int i=0;i<=数组.length-1;i++){
		sout(数组[i]);

}

案例1：二分查找

首先了解二分查找和顺序查找（看图）
在这里插入图片描述

二分查找的要求：
数组有序

//二分查找
public class SecondFIND {
    public static void main(String[] args) {
        int[] str={1,2,3,4,5,6,7,8,9};
        int font=str[0];//初始化头部下标
        int tail=str[str.length-1];//初始化尾部下标
        int sum=9;//定义要查找的数字
        int mid;//初始化中间下标
        while(sum<=tail){//调用while循环，当查找的数小于等于尾部，执行循环
            mid=(font+tail)/2;//取两端下标之和的平均数作为中间数
            if(sum==str[mid]){
                System.out.println("找到了数字"+str[mid]);
                break;
            }else if (sum>str[mid]){
                font=mid+1;
            }else{
                tail=mid-1;
            }
        }
    }
}

案例2：数组的增加删除

①增加

方法一：（用比较查找插入的下标，然后通过下标插入）

package day07;
//数组的对应位置增加数字
public class SZInser {
    public static void main(String[] args) {
        int[] oldadr={1,2,3,5,6,7,8,9};
        int add=4;//定义增加数字的值
        int pid=0;//初始化下标
        //查找下标
        int[] newadr=new int[oldadr.length+1];//新的数组比旧的数组多一位
        for (int i = 0; i <=oldadr.length-1 ;i++) {
            if (add<oldadr[i]){
                pid=i;//获得下标
                break;//直接退出循环，减少计算
            }
        }
       //插入新的数组
        for (int k = 0; k <=newadr.length-1 ; k++) {
            if(k<pid){//插入数组前的数字依旧插入
                newadr[k]=oldadr[k];
            }else if (k==pid){//插入要插入的数字
                newadr[k]=add;
            }else {//后面数组向后移进一位
                newadr[k]=oldadr[k-1];
            }
        }

        //遍历新的数组
        for (int l = 0; l <=newadr.length-1; l++) {
            System.out.print(newadr[l]);
        }
    }
}

①+增加

方法二：（直接填入数组，用冒泡排序的方法调整位置

package day07;
//用冒泡排序的方法，将数插入数组合适的位置
public class MPXCR {
    public static void main(String[] args) {
        int [] str={1,2,3,5,6,7};//给定一串数组
        int add=4;//要插入的数字
        int [] newstr=new int[str.length+1];//新的数组（原来的长度+1）
        for (int p = 0; p <=newstr.length-2; p++) {//旧的数组填充新的数组，并且把新元素放进去
            newstr[p]=str[p];
        }newstr[newstr.length-1]=add;
        for (int i = 0; i <newstr.length-2 ; i++) {//冒泡排序
            for (int j = 0; j <newstr.length-1-i; j++) {
                if(newstr[j]>newstr[j+1]){
                    int stmp=newstr[j+1];
                    newstr[j+1]=newstr[j];
                    newstr[j]=stmp;
                }
            }
        }
        //遍历
        for (int k = 0; k <=newstr.length-1 ; k++) {
            System.out.print(newstr[k]);
        }
    }
}

③删除

（确定删除下标，通过下标移除）

package day07;
//删除数据
public class SZupdata {
    public static void main(String[] args) {
        int[] oldadr={1,2,3,5,6,7,8,9};
        int add=5;
        int pid=0;
        //查找下标
        int[] newadr=new int[oldadr.length-1];
        for (int i = 0; i <=oldadr.length-1 ;i++) {
            if (add<oldadr[i]){
                pid=i-1;//获得下标
                break;//直接退出循环，减少计算
            }

        }
        //放入新的数组
        for (int k = 0; k <=newadr.length-1 ; k++) {
            if(k<pid){
                newadr[k]=oldadr[k];
            }else if (k>=pid){
                newadr[k]=oldadr[k+1];
            }
        }

        //遍历新的数组
        for (int l = 0; l <=newadr.length-1; l++) {
            System.out.print(newadr[l]);
        }
    }
}

二维数组

定义的格式：
两种格式

格式1：

数据类型[][] 变量名

例如: int[][] arr
格式2：
数据类型变量名[][]
例如: int arr[][]
注意：

两种格式使用是没有区别的
区别在意执行的过程
格式一是直接定义数组
格式二是先定义数据类型在定义数组

访问二维数组中的元素
通过索引来访问
格式:数组名称[索引][索引]

动态初始化:

初始化时只指定数组的长度，由系统为数组分配初始值

格式:

数据类型[][] 变量名=new 数据类型[数组长度][数组长度];

  例如:    int[][] arr=new int[5][5];

静态初始化:

初始化时指定每个数组元素的初始值，由系统决定数组长度

格式:

数据类型[][] 变量名=new 数据类型[][]{{数据1...}，{数据2...}...};

例如: int[][] arr=new int[][]{{1,2},{3,4},{5,6,7}};

可以简化为:

数据类型[][] 变量名={{数据1...}，{数据2...}...};

注意:简化写法中使用的是大括号

例如: int[][] arr={{1,2},{3,4},{5,6,7}};

二维数组注意：
在这里插入图片描述

方法

定义：

方法是将具有独立运行的代码块组织(封装)为一个整体，使其具有特殊功能的代码集

注意:

	方法必须先创建才可以使用，该过程称之为方法定义

	方法定义后需要手动使用后才执行，该过程称之为方法调用

定义格式1:

public static void 方法名(){
			方法体
		}定义

例：

//格式1
public class Demo1 {
    public static void main(String[] args) {
        System.out.println("开始");//开始
        ff();//执行方法
        System.out.println("结束");//结束
}
public static void ff(){
    System.out.println("方法体");
    }

}

在这里插入图片描述

格式2:

		public static void 方法名(参数1,参数2...参数n){
			方法体
			}定义

例：

//格式2
public class Demo1 {
    public static void main(String[] args) {
        ff(5,6);
}
public static void ff(int a,int b){
    System.out.println(a+b);
    }

}

在这里插入图片描述

格式3:

		public static 返回值数据类型 方法名(参数1,参数2...参数n){
			方法体
			return 数据:
	}

例：

//格式3
public class demo03 {
    public static void main(String[] args) {
        int i=ff(5,6 ,10);
        System.out.println(i);
    }
    public static int ff(int a,int b ,int c){
        return a+b+c;
    }

}

在这里插入图片描述

通用格式:
		public static 返回值数据类型 方法名(参数1,参数2...参数n){
			方法体
			return 数据:
		}

案例计算器

package day07;
import java.util.Scanner;
public class JiSuanQi {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (true)
        {
        System.out.println("计算器：");
        System.out.println("请输入第一个数");
        int x=scanner.nextInt();
        System.out.println("运算符号");
        String z=scanner.next();
        System.out.println("请输入第二个数");
        int y=scanner.nextInt();
        socet(x,y,z);
            System.out.println("是否退出：(Y/N):");
            String ESC=scanner.next();
            ESCPG(ESC);
            if(ESC.equals("Y")){
                break;
            }
        }
    }
    public static void socet(int a,int b,String c){
        if(c.equals("+")){
            System.out.println("结果"+(a+b));
        }else if(c.equals("-"))
        {
            System.out.println("结果"+(a-b));
        }else if (c.equals("*"))
        {
            System.out.println("结果"+(a*b));
        }else if(c.equals("/")){
            System.out.println("结果"+(a/b));
        }
    }
    public static void ESCPG(String e){
        if(e.equals("Y")){
            System.out.println("退出");

        }

    }
}

格式注意：

public static:固定格式
返回值数据类型:void和其他
方法名:方法的标识符(用户识别方法)

参数:

等同于定义变量:数据类型变量名
多个参数之间以逗号做分割
方法定义上的参数叫做形参

return:

返回数据,谁调用返回给谁,返回到方法调用

return表示方法已经结束,return写在最后,return之后不能跟任何内容

void中return可写可不写,如果有return返回数据

方法重载

特点:

	1.在同一个类之中
	2.方法名相同,参数不同(个数不同,类型不同)
	3.和返回值无关,和返回值的数据类型无关

方法调用:
	格式:
		方法名(参数);

package day07;
//方法重载  方法名相同，但是参数不同(个数不同,类型不同)
public class demo02 {
    public static void main(String[] args) {
      sum(1,2,3);  
      sum(1,2);
      sum("1","2","3");
    }
    public static int sum(int a,int b,int c){
       return a+b+c;     
    }
    public static int sum(int a,int b){
        return a+b;
    }public static String sum(String A,String B,String C){
        return A+B+C;
    }
}

注意:
方法调用只能在main或者方法中
方法调用本身叫做递归(没有特殊的需求,不建议使用)
方法调用上面的参数叫做实参

参数传递:

基本数据类型和引用数据类型,作为参数进行传递,本身的值不会改变

引用数据类型地址值指向的空间,空间中的元素可以发生改变方法的

举例注意2递归：

什么是递归？（来继续看图哈哈😂）
在这里插入图片描述

在这里插入图片描述

结果：造成死循环，然后运行不堪重负停止。

在这里插入图片描述

举例注意5：

思考：结果为啥
package day07;

public class Demo1 {
    public static void main(String[] args) {
        int[][] sz={{1,2,3},{4,5,6},{7,8,9}};
        System.out.println(sz[0]);//结果1
       ff(sz[0]);//结果2
        System.out.println(sz[0]);//结果3
}
public static int ff(int fs[]){
       fs[0]=100;
    System.out.println(fs[0]);//结果2--
       return fs[0];
    }
}

结果：

在这里插入图片描述
练习：

简答题

在多重循环中，如何在内层循环中使用break跳出外层循环。
方法重载的定义、作用和判断依据
递归的定义和优缺点
（答案见下一章）

上一期答案：
填空题

连续
length
声明数组
null
array[0].length
|
|
|
|

上一章DAY06-Random和数组1
下一章-DAY08-Debug功能使用与练习题（factions）
天天更新不容易，随手点个小赞👍，你说是吧，吴彦祖！O(∩_∩)O
在这里插入图片描述

你的动作太慢了！

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
5
评论
一起重新开始学大数据-java篇-DAY07-数组2和方法

一起重新开始学大数据-java篇DAY07-数组2和方法学习内容：1. 数组格式、访问、二分查找和数组的增加、删除2. 方法的调用和各种注意事项数组知识点回顾：数组:存储多个数据类型相同的存储模型定义:格式1:直接创建数组数据类型[] 变量名;格式2:先创建基本数据类型,在创建数组数据类型变量名[];注意:建议使用格式1动态初始化:手动指定长度,系统分配默认值(int默认值0,String为null)格式: 数据类型[] 变量名=new int[长度];
复制链接

扫一扫