每日学习总结：数组、数组工具类、方法的重载（Day05）

本文主要是介绍每日学习总结：数组、数组工具类、方法的重载（Day05），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1.1 概念

数组Array，标志是[ ] ,用于储存多个相同类型数据的集合。

想要获取数组中的元素值，可以通过脚标（下标）来获取数组下标是从0开始的,下标的最大值是数组的长度减1。

1.2 创建数组

数组的创建方式一般分为动态初始化和静态初始化

1. 动态初始化
   int[] a = new int[5];
2. 静态初始化
   int[] b = new int[]{1,2,3,4,5};
   int[] c = {1,2,3,4,5};

1.3 数组的长度

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

1.4 练习：向数组中存入数据hello

package ningbo.array;

import sun.security.pkcs11.wrapper.CK_X9_42_DH2_DERIVE_PARAMS;

import java.util.Arrays;

/**
 * @Author 宁铂
 * @Date 2021/7/7 8:43
 * @Version 1.0
 */
public class TestCreateArray {
    /** 本类用于练习数组的创建和使用 */
    public static void main(String[] args) {
        /** 创建数组，并存入数据 “Hello” */

        //静态数组 -- 需要指定具体的元素，元素之间用逗号隔开
        char[] c1 = {'H','e','l','l','o'};
        char[] c2 = new char[]{'H','e','l','l','o'};

        //动态数组 -- 不需要指定具体的元素
        //在内存中开辟一块连续的空间存放5个字符
        char[] c3 = new char[5];

        /**
         * 通过下标来操作数组中的元素
         * 数组下标是从0开始的,下标的最大值是数组的长度减1 */
        c3[0] = 'H'; //通过下标给数组赋值
        c3[1] = 'e';
        c3[2] = 'l';
        c3[3] = 'l';
        c3[4] = 'o';

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);

        //创建String类型的数组
        String[] c4 = {"a","b","c","d"};
        /** 关于数组的打印，char类型在底层做了处理
         *  可以直接打印出数组中的具体元素
         *  但是除了char类型以外的所有数组
         *  都不可以直接打印数组中的具体内容
         *  如果想要查看数组中的具体元素，需要使用工具类Arrays
         *  Arrays.toString(数组名)，需要导包
         * */
        System.out.println(c4);
        System.out.println(Arrays.toString(c4));

        //获取数组的长度 -- 数组存放元素的个数
        /** 数组一旦创建，长度不可改变
         *  可以通过 数组名.length 来获取数组的长度/元素个数
         * */
        System.out.println(c1.length);
        System.out.println(c4.length);
    }
}

1.5 创建数组过程分析

程序创建数组 int[] a = new int[5]; 时发生了什么?

• 在内存中开辟一块连续的空间

• 给数组完成初始化的过程，默认值为零

• 完成初始化后会分配一个唯一的地址值

• 数组的地址值会交给引用类型的变量a来保存

• 根据下标给每个位置上的元素赋值

数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

1.6 数组的遍历

遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素.形式如下:
我们通过数组的下标操作数组,所以for循环变量操作的也是数组下标

1.7 练习-1：输出每个月的天数、创建随机数组

package ningbo.array;

import java.util.Arrays;
import java.util.Random;

/**
 * @Author 宁铂
 * @Date 2021/7/7 9:28
 * @Version 1.0
 */
public class TestArrayExec {
    /** 本类用于数组的遍历
     *  打印一年中每个月的天数 如:一月有31天
     *  需求2： 动态的向数组存入数据1-10；
     *  需求3：创建一个随机数组，数组的元素是1-100以内的整数
     * */
    public static void main(String[] args) {
        Day day = new Day();
        day.m1();
        day.m2();
        day.m3();
    }
}

class Day{
    public void m1(){
        /** 定义一个数组，保存12个月的天数 */
        int[] a = {31,28,31,30,31,30,31,31,30,31,30,31};

        /** 数组的遍历，使用for循环
         *  从哪开始：0 -- 下标0，是第一个元素
         *  到哪结束：a.length-1 -- 最大下标减一
         *  怎末变化：++
         * */
        for (int i = 0; i<=a.length-1; i++){
            System.out.println((i+1)+"月有"+a[i]+"天");
        }

    }

    public void m2(){
        //创建动态数组
        int[] a = new int[10];

        //动态向数组中赋值 -- 遍历数组
        for(int i = 0; i<=a.length-1; i++){
            a[i] = i+1;
        }
        System.out.println(Arrays.toString(a));

    }

    public void m3(){
        Random rand = new Random(); //随机数生成器

        int[] a = new int[8];
        for (int i = 0; i<= a.length-1;i++){
            a[i] = rand.nextInt(100);
        }
        System.out.println(Arrays.toString(a));
    }
}

2.1 Arrays.toString(数组)

tostring(数组名)打印非char类型数组,查看数组具体元素时,需要使用

2.2 Arrays.sort(数组)

sort(数组名)-直接对传入的乱序数组进行排序

package ningbo.array;

import java.util.Arrays;

/**
 * @Author 宁铂
 * @Date 2021/7/7 10:23
 * @Version 1.0
 */
public class TestArraysSort {
    /** 本类用于测试数组工具类Arrays的sort() */
    public static void main(String[] args) {
        /** sort():可以给数组排序
         *  创建一个无序的数组
         * */
        int[] a = new int[]{21,98,76,23,25};

        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

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

copyof(原数组的名字,新数组的长度)

• 如果新数组的长度与原数组相同-普通复制
• 如果新数组的长度小于原数组的长度--数组的缩容
• 如果新数组的长度大于原数组的长度-数组的扩容

注意:本方法不会修改原数组,创建的是指定长度的新数组

2.5 练习：练习Arrays. copyOf(数组，新的长度)

package ningbo.array;

import java.util.Arrays;

/**
 * @Author 宁铂
 * @Date 2021/7/7 10:31
 * @Version 1.0
 */
public class TestArraysCopyOf {
    /** 本类用来测试工具类的copy of（）方法 */
    public static void main(String[] args) {
        /** 创建一个原数组
         *  copyOf() 用于数组的复制，有两参数：
         *  1。要复制的数组名
         *  2.新数组的长度
         * */
        int[] from = new int[]{1,2,3,4,5};

        /** 复制数组 */
        int[] to = Arrays.copyOf(from, 5);

        /** 数组的缩容 -- 缩小容量，类似于截取 */
        int[] to2 = Arrays.copyOf(from, 3);

        /** 数组的扩展 -- 扩展容量，不足的位置由对应类型的默认值，来填充 */
        int[] to3 = Arrays.copyOf(from, 8);

        /** 可以指定首位复制数组(截取一部分复制数组)
         *  三个参数：
         *  1.复制那个数组
         *  2.从哪开始 -- 数组下标
         *  3.到哪结束 -- 数组下标，含头不含尾
         * */
        int[] to4 = Arrays.copyOfRange(from, 2, 4);

        /** 打印复制好的新数组 */
        System.out.println(Arrays.toString(to));
        System.out.println(Arrays.toString(to2));
        System.out.println(Arrays.toString(to3));
        System.out.println(Arrays.toString(to4));
    }
}

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

3.1练习：测试方法的重载

package ningbo.method;

import sun.applet.Main;

/**
 * @Author 宁铂
 * @Date 2021/7/7 10:57
 * @Version 1.0
 */
public class TestMethodOverload {
    /** 测试方法的重载 */
    public static void main(String[] args) {
        method met = new method();

        /** 方法的重载：
         * 在同一个类中，存在方法名相同，但是参数列表不同的方法
         *
         *  方法的重载现象：
         *  (int a, String b) and (int b,String a) -- 不构成重载
         *  (int a, String b) and (String a, int b) -- 构成重载
         *  在同类中，方法的参数个数相同
         *  注意：查看的是对应位置上参数的类型，与参数名无关
         *  当参数个数不同时，一定构成重载
         *  当参数个数相同时，不一定构成重载，具体要看参数类型
         * */
        met.demo(); //调用无参的method()
        met.demo(3);
        met.demo("宁铂",22);
    }
}

class method{
    public void demo(){
        System.out.println("哈哈哈哈哈哈，我没有参数···");
    }

    public void demo(int i){
        System.out.println("哈哈哈哈哈哈，我终于参数···"+i);
    }

    public void demo(String x,int y){
        System.out.println(x+"今年"+y+"岁了！");
    }
}

这篇关于每日学习总结：数组、数组工具类、方法的重载（Day05）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！