了解数组,一些练习

米斯木

已于 2023-10-07 16:20:52 修改

阅读量32

点赞数

分类专栏： Java学习笔记文章标签： java 开发语言

于 2023-04-03 19:15:53 首次发布

本文链接：https://blog.csdn.net/missmoonlight/article/details/129937015

版权

Java学习笔记专栏收录该内容

24 篇文章 0 订阅

订阅专栏

复习

了解IT

搭建开发环境

数据类型

关键字

保留字

标识符

变量

常亮

运算符

分支语句

循环语句

方法

作用:封装一段代码,使其便于使用

使用步骤

1.定义
2.调用

定义

访问权限修饰符 修饰符 返回值类型 方法名(形参列表){
    方法体
}
访问权限修饰符:暂时使用public
修饰符:暂时使用static
返回值类型:返回值的数据类型
    注意:
        1.没有返回值就用void
        2.如果方法体中有return,就是有返回值
        3.一个类中不能出现两个或两个以上,方法名相同,形参列表也相同的方法
方法名:自定义
形参列表:声明的多个变量,中间用","隔开(可有可无)

使用

语法:
    方法名(实参列表);
    变量名 = 方法名(实参列表);//有返回值时才可以用变量接收

今日

数组

作用:容纳一组数据类型相同的数据

名词

长度:一个数组最大可容纳的数据个数
下标:数据在数组中的位置,从0开始到长度减一结束
元素:数组中存储的数据

特点

1.长度不可变
2.存储数据类型一致

步骤

1.声明
2.创建
3.使用

声明

语法:
    数据类型[] 数组名;(主流)
    数据类型 数组名[];

创建:

静态创建:
    语法:
        数据类型[] 数组名 = {值1,值2,....,值n};
    注意:
        1.声明和创建必须在一起,同时进行
        2.其长度就是创建时值的个数
动态创建:
    语法:
        带值
            数组名 = new 数据类型[]{值1,值2,...,值n}
        不带值
            数组名 = new 数据类型[长度];

动态创建与静态创建的区别
    1.静态创建必须在声明时创建,动态创建可以将声明与创建分开,也可以同时进行
    2.内存上来说
        静态创建的内容在常亮区
        动态创建的内容在堆内存
    3.静态创建是在代码加载时分配内存空间,动态创建是在代码运行时分配的空间
    
注意:
    堆内存中的数据有默认值
        基本数据类型默认为0
        引用数据类型默认为null
        boolean默认为false
        只有堆内存中有默认值

使用

基本使用
    改
        修改指定位置的数据
            语法:
                数组名[下标] = 值;
    查
        查询数组长度
            语法:
                数组名.leangth
        查询指定位置的数据
            语法:
                数组名[下标]
            注意:
                下标要在取值范围内,否则会产生数组下标越界

扩展

    遍历:将数组或集合中的数据逐个取出
        方式1:for循环
        方式2:foreach(只能做遍历)
            语法:
                for(数据类型 变量名 : 要遍历的数组名){
                System.out.println(变量名);
                }
        注意:foreach(增强for循环)在遍历时的速度是普通的for的3倍

    复制:将数组A中的数据复制到B中
        思路:
        1.创建一个新数组
        要求
            1.长度等于老数组
            2.新数组数据类型要与老数组类型一致
        2.遍历老数组
            遍历使用普通遍历
        3.将老数组的值取出,赋值给新数组对应位置

    扩容:将数组变大
        思路:
        1.创建一个新数组
        要求
            1.长度大于老数组
            2.新数组数据类型要与老数组类型一致
        2.遍历老数组
            遍历使用普通遍历
        3.将老数组的值取出,赋值给新数组对应位置
        4.将新数组赋值给老数组

二维数组

概念:将数组作为数据存在数组中
步骤:
    1.声明
    2.创建
    3.使用

声明
    数据类型[][] 数组名;

创建
    静态创建
        注意:声明与创建同时进行
        语法:
            数据类型[][] 数组名 = {
                {值1,值2,...},
                {值3,值4,...},
                ...
            };
    动态创建
        带值
            语法:
                数组名 = new数据类型[][]{
                    {值1,值2,...},
                    {值3,值4,...},
                    ...
                };
                
        不带值
            语法:
                数组名 = new数据类型[x][y];
                x:二维数组中可容纳一维数组的个数,必须在创建时声明
                y:一维数组中可容纳元素的个数,可不写
注意:
    二维数组的长度是指其中一维数组的个数

使用
    改
        修改二维数组中指定的一维数组
            数组名[下标] = 新数组;
        修改二维数组中指定位置的元素
            数组名[x][y] = 新值;
    查
        查询数组长度
            数组名.length
        查询二维数组中指定位置的一维数组
            数组名[下标]
        查询二维数组指定位置的元素
            数组名[x][y]

遍历:
    思路:
        1.遍历二维数组,获得一维数组
        2.遍历一维数组
        就是两个循环 嵌套

public class Demo09 {
    public static void main(String[] args) {
        int[][] nums = new int[][]{
                {11,12,13},
                {21,22},
                {31,32,33,34,35},
                {41}
        };
        //遍历二维数组
//        for (int i= 0; i < nums.length; i++){
//            //获取二维数组中的一维数组
//            int[] ns = nums[i];
//            //遍历一维数组
//            for(int j = 0; j < ns.length; j++){
//                System.out.print(ns[j]+"\t");
//            }
//            System.out.println();
//        }

        //遍历二维数组
//        for (int i= 0; i < nums.length; i++){
//            //遍历一维数组
//            for(int j = 0; j < nums[i].length; j++){
//                System.out.print(nums[i][j]+"\t");
//            }
//            System.out.println();
//        }

        for (int[] ns:nums){
            for (int n:ns){
                System.out.print(n+"\t");
            }
            System.out.println();
        }

    }
}

数组与方法

例子:定义一个方法计算多数之和
public static void sum(int[] nums){
    int sum= 0;
    for(int i:nums){
        sum = sum + i;
    }
}
int[] nums = {1,2,3,4,5,6,7,8};
sum(nums);


例子:定义一个方法,计算两数之和.要求返回值有加数,被加数,和
public static int[] add(int a,int b){
    int x = a + b;
    int[] nums = {a,b,x};
    return nums;
}

new在堆内存中创建一个空间

可变参数

作用:解决实参的长度必须与形参长度一致的困扰

语法: 数据类型... 变量名

使用位置:形参尾部

注意:一个方法只能有一个可变参数

假设计算多个数之和,多少个数未知,用方法写

//计算两个数之和
public static void sum(int a,int b){
    sum = a + b;
}

//把需计算的数放到数组中,把数组传入方法中
int[] nums = {1,3,4,5,6,7,8};
sum01(nums);

public static void sum01(int[] nums){
   int sum = 0;
   for (int num : nums) {
       sum = sum + num;
   }
   System.out.println("和为:"+sum);
}

sum02(1,2,3,4,5,6,7,8,9);

//可变参数
public static void sum02(int... ns){
    int sum = 0;
    for (int num : ns) {
        sum = sum + num;
    }
    System.out.println("和为:"+sum);
}

作业

0,整理笔记

1,键盘输入一个长整数数（文件大小），人性化显示（带bytes, k, m, g, t单位）

2,遍历数组

3,对数组进行扩容

4,下列数组的声明有哪些是对的？错的应该怎么修改？
A. int[] a;
B. int a[] = new int[3];
C. int[] a;a = {1,2,3,4,5};
D. int[] a = new int[3]{1,2,3};

5,下列哪些是方法重载?
    public static void open(){} 
    public static void open(int a){} 
    static void open(int a,int b){} 
    public static void open(double a,int b){} 
    public static void open(int a,double b){}
    public void open(int i,double d){} 
    public static void OPEN(){} 
    public static void open(int i,int j){}
    
6,数组的遍历 :
    定义一个数组,静态初始化,将数组中的元素按照下面格式输出
    {元素1, 元素2, 元素3, 元素4 ....} ,使用方法调用完成(遍历,直接输出,没有返回值类型 void)
如何将10数存入数组中 
    提示:
        在定义一个方法,专门去遍历数组,打印输出
        调用方法将数组遍历即可!
        
7,键盘输入一个正整数，打印它的二进制的数值数组

8,键盘输入两个整数，打印它们的公约数

9,寻找数组中的最大值

10,寻找数组中的最小值

11,寻找数组中的最大值下标

12,寻找数组中的最小值下标

13,将最大值移动到数组的末尾

14,将最小值移动到数组的开头

15,编写方法，求数组元素的平均值
要求
    1)定义一个方法，求数组的平均值
    2)在主方法中定义对象，并初始化一个float类型的数组(直接在main方法中静态初始化一些值)，
    调用方法求数组元素的平均值，并将平 均值打印输出
    
16,键盘录入5个不同int类型的数据，将数据存储在数组中,获取数组的最大值(数组静态初始化）

17,定义一个数组：int a[] = {9,15,3,1,7,2},将数组进行逆序
    (结果是[2,7,1,3,15,9]),编写一个方法完成