Java基础-数组

最新推荐文章于 2024-05-20 15:31:36 发布
最新推荐文章于 2024-05-20 15:31:36 发布
阅读量161 收藏
点赞数
分类专栏： 编程基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ying_ph/article/details/111522070
版权

数组

1.数组

1.1.数组的概念

  • 数组是引用类型，数组元素可以是基本数据类型也可以是引用数据类型
  • 其实是个容器，是一组 相同类型的数据的容器；
  • 数组元素指的就是数组种的数值

1.1.数组特性

1，数组长度一旦确定不能改变

2, 数组的索引从 0 开始；

3，数组的内存空间是连续的；访问数组非常

2.1.数组初始化3种

 	/**
     * 数组的初始化方式
     */
    public static void method1() {
        int a;
        //声明一个数组 数据类型[] 数组名
//        int[] arr; //等价与 int arr[]
        //1,第一种数组初始化, 数组的长度为 6
        int[] arr = new int[6];

        //2,第2种初始化
        int[] arr2 = {67, 90, 78, 99}; // 0-3

        // 3，第3种初始化
        int[] arr3 = new int[]{67, 78, 99, 55};
    }

2.2.数组的使用

1，数组元素赋值

/**
     * 给数组元素赋值和取值
     */
    public static void method2() {
        double[] stuScores = new double[10];
        //1,如何求数组长度
        System.out.println("数组长度" + stuScores.length);
        //2,取出数组元素的值 索引号 0-（数组长度-1）
        System.out.println(stuScores[0]);
        //3，给数组元素赋值
        stuScores[0] = 98;
        System.out.println(stuScores[0]);
        //依次给数组元素赋值
        for (int i = 0; i < stuScores.length; i++) {
            stuScores[i] = Math.random() * 100;
        }
        //循环遍历所有的数组元素
        for (int i = 0; i < stuScores.length; i++) {
            System.out.println(stuScores[i]);
        }
    }

2,使用数组的计算均值，最值

 /**
     * 使用数组得到学生成绩的 平均值 最值
     */
    public static void method3() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入学生人数：");
        int stuNum = sc.nextInt();
        //此数组用来存放学生成绩
        int[] scores = new int[stuNum];
        int sum = 0;
        for (int i = 0; i < stuNum; i++) {
            int score = (int) (Math.random() * 100);
            scores[i] = score;
            sum += scores[i];
            System.out.println("第" + (i + 1) + "个学生成绩是：" + score);
        }
        System.out.println("总的成绩：" + sum);
        System.out.println("平均成绩：" + sum / stuNum);
        // 得到最大值 ,最小值；先假设第一个就是最大值，循环进行比较
        int maxScore = scores[0], maxIndex = 0;
        int minScore = scores[0], minIndex = 0;
        for (int i = 1; i < scores.length; i++) {
            if (maxScore < scores[i]) {
                maxScore = scores[i];
                maxIndex = i;
            }
            if (minScore > scores[i]) {
                minScore = scores[i];
                minIndex = i;
            }
        }
        System.out.println("最高成绩为 " + maxScore + "索引值是 " + maxIndex);
        System.out.println("最低成绩为 " + minScore + "索引值是 " + minIndex);
    }

3,数组的拷贝,引用的直接赋值和值的拷贝

/**
     * 数组的拷贝
     */
    public static void method4() {
        int[] arr1 = {34, 56, 78, 99};
        // 直接把arr1的引用赋值给arr2 ，引用的直接拷贝
        /*int[] arr2 = arr1;
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        //改变数组arr1的数组元素值
        arr1[1] = 69;
        System.out.println(arr2[1]);*/
        //数组元素值的拷贝
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        arr1[1] = 69;
        System.out.println(arr2[1]);
    }

4，数组的遍历

  /**
     * 数组元素的2种遍历方式
     */
    public static void method5() {
        int[] arr = {66, 56, 87, 99, 50};
        // 1，普通for循环遍历
      /*  for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }*/
        //2，增强for循环遍历
        for (int b : arr) {
            System.out.println(b);
        }
    }

2.3. Arrays工具类的使用

    /**
     * Arrays是个工具类，里面封装的是操作数组相关的方法;
     */
	public static void method6() {
        int[] arr = {66, 56, 87, 99, 50, 2, 1};
        double[] dos = {5.6, 9.8, 2.3};
        int a = 10;
        //1，把数组元素以字符串形式打印出来
        System.out.println(Arrays.toString(arr));
        // 2，对数组元素进行排序，源数组发生改变
       /* Arrays.sort(arr);
        System.out.println("============");
        System.out.println(Arrays.toString(arr));*/
        // 3，对数组进行拷贝，第二个参数newLength代表新数组的长度，与源数组不一定相等，如果大于源数组长度会赋默认值（int是0，double是0.0）
        int[] arr2 = Arrays.copyOf(arr, 10);
        System.out.println(Arrays.toString(arr2));
    }

2.4.多维数组-二维数组

1，二维数组的初始化

    /**
     * 二维数组的使用，二维数组里面的数组元素是一维数组
     */
    public static void method7() {
        //3表示有3个一维数组,每个一维数组长度是2
        int[][] a1 = new int[3][2];
        a1[0][0] = 1;
        a1[0][1] = 2;
        a1[1][0] = 3;
        a1[1][1] = 4;
        a1[2][0] = 5;
        a1[2][1] = 6;
        //增强for+Arrays.toString打印
        for (int[] ints : a1) {
            System.out.println(Arrays.toString(ints));
    }
//结果
[1, 2]
[3, 4]
[5, 6]

2，二维数组的使用，录入多个班级的学生成绩

 /**
     * 使用二维数组保存多个班级的成绩 3  1(20)  2(30)  3(35)
     */
    public static void method8() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入班级个数：");
        int classNum = sc.nextInt();
        int[][] stuScore = new int[classNum][];
        for (int i = 0; i < stuScore.length; i++) {
            System.out.println("请输入第" + (i + 1) + "班级人数：");
            int stuNum = sc.nextInt();
            stuScore[i] = new int[stuNum];
        }
        //依次给 每个班的每个学生的成绩进行赋值
        for (int i = 0; i < classNum; i++) {
            for (int j = 0; j < stuScore[i].length; j++) {
                stuScore[i][j] = (int) (Math.random() * 100);
            }
        }
        //遍历每个班 每个学生的成绩
        for (int i = 0; i < classNum; i++) {
            System.out.println(Arrays.toString(stuScore[i]));
        }
    }

2.方法

2.1.方法的定义

  • 其实实现一个功能的代码片段; 封装到方法中 可以实现代码重用

2.2.如何声明一个方法

1，声明方法。形参是方法声明时的参数，实参是实际调用时的传值

/**
     * 方法：其实实现一个功能的代码片段; 封装到方法中 可以实现代码重用
     * 权限修饰符 static不是必须的  void代表方法没有返回值(有返回值的话要加return关键字) 方法名-首字母小写遵守驼峰标志（方法参数列表）
     * return 只能返回一个值
     */
    public static int[] sortDescent(int[] sortArr) {
        Arrays.sort(sortArr);
//        System.out.println(Arrays.toString(sortArr));
        int[] newArr = new int[sortArr.length];
        int index = 0;
        for (int i = sortArr.length - 1; i >= 0; i--) { //4,3,2
            newArr[index] = sortArr[i];
            index++;
        }
//        System.out.println(Arrays.toString(newArr));
        return newArr;
    }


 	/**
     * op1,op2 方法形参；add(10, 20)真正调用的时候10,20称为方法的实参
     *
     * @return 把值返回给调用者
     */
    public static int add(int op1, int op2) {
        int sum = op1 + op2;
        return sum;
    }

2，使用方法（调用方法）

 		//调用方法
		sortDescent(aa);
        sortDescent(bb);
        sortDescent(cc);
//        int cc = add(10, 20);
        method2(10, "ss");

3，定义方法（四类）

/**
     * 有参数有返回值
     *
     * @param str1
     * @param a
     * @param b
     * @return
     */
    public static String method4(String str1, int a, double b) {
        return "";
    }

    /**
     * 无参数有返回值,一定要有return关键字
     *
     * @return
     */
    public static double method3() {
        System.out.println("");
        double d = 2.2;
        return d;
    }

    /**
     * 有参数无返回值
     *
     * @param op
     * @param str
     */
    public static void method2(int op, String str) {
        System.out.println("执行代码逻辑");
    }

    /**
     * 无参无返回值 进行调用的时候 method1();
     */
    public static void method1() {
        System.out.println("========");
        System.out.println("========");
        System.out.println("========");
        System.out.println("========");
    }

2.3.方法的重载

2.3.1.什么是方法重载(overload)

  • 方法名相同，参数列表不同（参数个数不同，参数类型不同，参数顺序不同）
  • 例如Arrays.sort(int[] a) 就是方法的重载
    public static double[] sortDescent(double[] sortArr) {
        return null;
    }

    public static float[] sortDescent(float[] sortArr) {
        return null;
    }

2.4.方法递归调用

  • 方法自己调用自己
 /**
     * 斐波那契数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368……
     * @param number
     * @return
     */
    public static int fibonacci(int number) {
        if (number == 1 || number == 0) {
            return number;
        } else {
            return fibonacci(number - 1) + fibonacci(number - 2);
        }
    }

注意点：

​ 递归调用层次过深 会发生栈空间溢出

3.排序算法

1，冒泡排序

算法原理：

​ 将相邻的两个元素进行比较，最大的值放在右端。
N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。

/**
     * 冒泡排序
     */
    public static void bubbleSort(int[] sort) {
        int temp;
        //外层总共进行了数组长度-1趟
        for (int i = 0; i < sort.length - 1; i++) {
            for (int s = 0; s < sort.length - 1 - i; s++) {
                if (sort[s] > sort[s + 1]) {
                    temp = sort[s];
                    sort[s] = sort[s + 1];
                    sort[s + 1] = temp;
                }
            }
            System.out.println(Arrays.toString(sort));
        }
    }

2，选择排序

算法原理：

​ 从第一个元素开始，分别与后面的元素相比较，找到最小的元素与第一个元素交换位置；从第二个元素开始，分别与后面的元素相比较，找到剩余元素中最小的元素，与第二个元素交换；重复上述步骤，直到所有的元素都排成由小到大为止。

 /**
     * 选择排序,每轮循环都会找到一个最小值所在的索引
     *
     * @param sort
     */
    public static void selectionSort(int[] sort) {
        int minIndex, temp;
        for (int i = 0; i < sort.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < sort.length; j++) {
                if (sort[minIndex] > sort[j]) {
                    minIndex = j;
                }
            }
            // 互换位置
            if (i != minIndex) {
                temp = sort[i];
                sort[i] = sort[minIndex];
                sort[minIndex] = temp;
            }
            System.out.println(Arrays.toString(sort));
        }
    }

3，插入排序

算法原理：

​ 将指针指向某个元素，假设该元素左侧的元素全部有序，将该元素抽取出来，然后按照从右往左的顺序分别与其左边的元素比较，遇到比其大的元素便将元素右移，直到找到比该元素小的元素或者找到最左面发现其左侧的元素都比它大，停止.
此时会出现一个空位，将该元素放入到空位中，此时该元素左侧的元素都比它小，右侧的元素都比它大；

 /**
     * 插入排序
     * @param sort
     */
    public static void insertSort(int[] sort) {
        int leftIndex, current;
        for (int i = 1; i < sort.length; i++) {
            leftIndex = i - 1;
            current = sort[i];
            while (leftIndex >= 0 && sort[leftIndex] > current) {
                sort[leftIndex + 1] = sort[leftIndex];
                leftIndex--; //
            }
            //插入的索引值
            sort[leftIndex + 1] = current;
            System.out.println(Arrays.toString(sort));
        }
    }
一枚小蜗牛H
关注
专栏目录
培训-Java基础-数组&集合.ppt
04-30
培训-Java基础-数组&集合.ppt 培训用的ppt 主要讲了java数组和集合 供需要的朋友使用
Java基础--数组练习2
07-25
Java基础之数组练习2
Java基础学习之数组
qq_44206313的博客
05-15 185
作者：kuikui 一、数组的概述 1. 数组的理解： 数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的 方式对这些数据进行统一管理。 2. 数组相关的概念： 数组名 元素 角标、下标、索引 数组的长度：元素的个数 3. 数组的特点： 数组是序排列的 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 创建数组对象会在内存中开辟一整块连续的空间 数组的长度一旦确定，就不能修改。 4. 数组的分类： ① 按照维数：一维数组、二维.
java(数组)
数据攻城狮的博客
10-05 263
文章目录1.数组的定义2.数组元素赋值3.访问数组元素4.数组最值5.数组排序6.二维数组 1.数组的定义 int[] x; x=new int[10]; //创建一个长度为10的数组 相当于 int[] x=new int[10]; 2.数组元素赋值 package java自学博客; public class Java数组 { public static void main(String[] args) { int[] x= {0,1,2,3};//第一种方法 int[] y=
java之数组
MTS的博客
01-06 348
数组是有序排列的。 数组属于引用数据类型。数组元素既可以是引用数据类型也可以是基本数据类型。 创建数组对象会在内存中开辟一整块连续的空间。 数组的长度一旦确定不可以更改。 数组的初始化 int[ ] arr; arr = new int[ ]{1,2,3} //静态初始化 int[ ] arr1; arr1 = new int[10]; // 动态初始化 数组的默认值 整数型: 0 浮点型：0.0 char型：0或‘\u0000’（显示出来是空格） boolean型：false 引用型（Strin.
数组
weixin_55545748的博客
03-03 250
数组的概念： 一种容器，可以同时存放多个数据值 数组的特点： 1.数组是一种引用数据类型 2.数组中的多个数据，类型必须统一 3.数组的长度在程序运行期间不可改变 数组的初始化：在内存当中创建一个数组，并向其中赋予一些默认值 两种常见的初始化方式： 1.动态初始化（指定长度） 2.静态初始化（指定内容） 动态初始化数组格式： 数据类型【】数组名称=new数据类型【数组长度】； 创建时指定数组的长度 解析含义： 左侧数据类型：数组当中保存的数据，全都是统一的什么类型 左侧【】：代表一个数组 左侧数组名称：给数
【java】数组是基本类型还是引用类型
之虎者也的博客
12-20 6431
答：是引用类型。 这里通过一个简单的样例进行说明： public static void main(String[] args) { int[] a = {1,2}; int[] b = a; a[0] = 10; System.out.println(b[0]); //输出10 } 可以看到，把数组a的第一个值改为10后，输出b的第一个值也是10，a和b两个变量引用了同一个数组。虽然保存的是基本类型值int，但是数组本身是引用类型的。 ...
Educoder题目：Java入门 - 数组进阶答案解析.md
11-01
Educoder题目：Java入门 - 数组进阶答案解析
Educoder题目：Java入门 - 数组基础答案解析.md
11-01
Educoder题目：Java入门 - 数组基础答案解析
头歌之Java入门 - 数组基础.rar
最新发布
07-09
里面的内容为： 第1关：初识数组 第2关：数组的使用 第3关：选择题（1） 第4关：数组练习-平均值和最大值 第5关：二维数组 第6关：选择题（2）
Java【数组】定义与使用，什么是引用类型你知道吗
yzhcjl_的博客
11-06 2872
数组的定义和使用，引用类型到底是什么，关于数组的库方法，你都会嘛
java基础语法（十六）数组
Apikaqiu的博客
04-10 1799
数组简介 Array: 1、java语言当中的数组是一种引用数据类型。不属于基本数据类型。数组的父类是Pbject. 2、数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合） 3、数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。 4、数组因为是引用类型，所以数组对象是堆内存当中。（数组是存储在堆当中的） 5、数组当中如果存储的是"java对象"的话，实际上存储的是...
引用数据类型——数组
2301_80434897的博客
05-20 701
引用数据类型——数组
JAVA基础篇（07）：引用数据类型之数组
綦枫Maple的博客
09-04 1025
引用数据类型-数组 引用数据类型包含类、接口和数组类型，还有一种特殊的null类型。这里我们讲数组。 数组的声明 一个数组只能存储一种类型的数据，如int型数组只能存int型数据。 数组是一种引用数据类型，如int是基本数据类型，但int[ ]就是引用数据类型了。 在定义数组三要素：变量类型，数组名，数组长度。 Java中声明一个数组的方式有两种： type[ ] arrayName type ...
Java数据类型
热门推荐
liumei90
09-27 1万+
一、数据类型 Java中主要有8中基本数据类型，分别是byte,short,int,long,char,boolean,float,double，具体如下： 1、boolean：数据值只有true或false，适用于逻辑计算。 2、char：char型（字符型）数据在内存中占用2个字节。char型数据用来表示通常意义上的字符，每个字符占2个字节，Java字符采用Unicode编码，它
数组是引用类型（基本类型变量与引用类型变量的区别）
AXiYa_Ari的博客
11-08 2918
二、基本类型变量与引用类型变量的区别 1、基本类型变量 1、概念：基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值； 2、举例 //基本类型变量 int a=10; int b=20; 2、引用类型变量 1、概念：引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。(类似与C语言中的指针) 2、举例 //引用类型的变量 String s="1234"; int[] array={1,2,3,4,5}; ...
关于数组的基本数据类型和引用类型
mickle_deng1的博客
04-19 8268
关于数组的基本数据类型和引用类型
数组类型引用和对象
weixin_38719347的博客
07-09 1367
参考https://www.zhihu.com/question/31203609 首先 局部变量和方法参数在jvm中的储存方法是相同的，都是在栈上开辟空间来储存的，随着进入方法开辟，退出方法回收。以32位JVM为例，boolean/byte/short/char/int/float以及引用都是分配4字节空间，long/double分配8字节空间。对于每个方法来说，最多占用多少空间是一定的，这...
C＃中数组是引用类型
拓荒者的跋涉
04-05 4738
C＃中数组是引用类型，C＃定义整型数组方式是：int [] intArray = {1,2,3};或int [] intArray = new int;而C++中定义整型数组的方式是：int intArray[] = {1,2,3};或int * intArray = new int;C＃中的数组可以是一维的也可以是多维的，同样也支持矩阵和参差不齐的数组。注意：定义多维数组（矩阵）的方式是[,,]
Java基础--数组练习2：互换元素案例与创建两个数组案例
Java基础--数组练习2 在Java中，数组是一种用来存储一组相同数据类型的数据的容器。它的特点包括数组是一个引用数据类型，数组内部可以存储基本类型或引用类型的元素。当我们创建数组时，需要指定数组的长度，并在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值