java day06 数组（一维数组、二维数组、可变参数）

最新推荐文章于 2024-01-07 11:05:37 发布

wzyyj

最新推荐文章于 2024-01-07 11:05:37 发布

阅读量182

点赞数

分类专栏： java学习日记文章标签：排序算法数据结构 java

本文链接：https://blog.csdn.net/qq_43642864/article/details/110003142

版权

java学习日记专栏收录该内容

33 篇文章 0 订阅

订阅专栏

1、数组概念

1.1 数组概念

1.存储多个相同数据类型的数据
2.长度固定

2、数组的声明和赋值

2.1 声明

声明语法：数据类型[] 数组名称 = new int[长度]
示例：int[] nums = new int[5];

2.2 赋值

int [] nums = new int[3];
nums[0] =1;
nums[1] =2;
nums[2] =3;

3、数组的组成

3.1 组成

数组中的每个数据被称为“数组元素”。
对元素的访问和取值被称为“元素访问”。
访问元素时，需要使用数组的下标，下标从0开始，一次+1，自动生成
访问语法：数组名[下标]；//例如：存：a[0]=1;取：a[0]

3.2 如何使用

如何存储100名学生的成绩？

办法：使用变量存储，重复声明100个double类型变量即可
缺点：麻烦，重复操作过多。

如何让100名学生成绩全部+1？

办法：100个变量重复相同操作，直至全部完毕。
缺点：无法进行统一的操作

解决上边两个问题，使用数组就很简单！

4、数组的遍历

4.1 for循环

遍历：从头至尾，逐一对数组的每一个元素进行访问。
遍历示例：

package Day06_Array;

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

/**
 * @author wzy
 * @version 1.0
 * @date 0021 2020-11-21 11:24
 */
public class  Demo04 {
    public static void main(String[] args){

        // 定义存储名字的数组names
        String[] names = {"码云","麻花头","马赛克","马保国"};
        // 定义存储点名次数的数组nums
        int[] nums = new int[names.length];

        Random random = new Random();  // 生成随机数

        // 随机点名数字
        for(int i=0;i<10;i++){
            //生成随机数 0~3
            int ranNum = random.nextInt(names.length);
            System.out.println(names[ranNum]+"被点名");
            // 次数+1
            nums[ranNum]++;
        }
        System.out.println("------------");

        // 遍历数组，打印每个人被点名的次数
        for (int i=0;i<names.length;i++){
            System.out.println(names[i]+":"+nums[i]);
        }
    }
}

4.2 foreach循环（增强for循环）

foreach遍历示例：

package Day06_Array;

/**
 * @author wzy
 * @version 1.0
 * @date 0023 2020-11-23 19:21
 */
public class Foreach {
    public static void main(String[] args) {
        String[] names = {"码云","麻花头","马赛克","马保国"};
        for (String str:names) {
            System.out.println(str);

        }
    }
}

5、可变长参数

概念：

可以接收多个同类型的实参
个数不限
使用方式和数组相同

语法：

数据类型…形参名(必须定义在形参列表后边，且只能有一个)

使用场景：

使用场景：当传递的参数都是相同类型但是数量不定的时候

6、二维数组

6.1 概念、语法

概念: 一维数组里存储y一维数组，二维数组中的元素是一维数组

语法:

int[][] 数组名=new 数据类型[行数][列数];
示例：int[][] = new int[3][3];

使用双下标访问二维数组中的元素：

第一个下标代表：行号（高维下标）。
第二个下标代表：列号（低维下标）。

6.2 遍历

package com.qf.ran.array;

/**
 * @author Ran
 * @since JDK 1.8
 *      二维数组
 *          一维数组里面存储一维数组
 *
 *      静态初始化和动态初始化的区别：
 *          静态初始化的一维数组长度可不一致
 *          动态初始化的一维数组长度必须一致
 *
 *      foreach的使用只能用来遍历打印数据，不能修改数据
 *
 */
public class Demo05 {
    public static void main(String[] args) {
        //动态初始化 3代表的是二维数组的长度  4代表的是1维数组的长度
        //String[][] books = new String[3][4];
        //String[][] books;
        //books = new String[3][4];
        //books[0][0] = "西游记";

        //静态初始化
        String[][] books = new String[][]{{"马宝国","马赛克"},{"雷军","雷公","雷震子"},{"昌老师"}};
        //System.out.println(books[1][2]);

        //一维数组
        int[] nums = {1,3,5,7};

        //一维数组的遍历
        System.out.println("---------一维数组的for循环遍历-------------");
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
        System.out.println("----------一维数组的foreach遍历------------");
        //num在foreach中称为循环值，每次循环自动接收数组中的元素
        //for(元素类型 循环值:数组)
        for(int num:nums){
            System.out.println(num);
        }

        //二维数组的遍历
        System.out.println("---------二维数组的for循环遍历-------------");
        for (int i = 0;i <books.length;i++){
            for (int j = 0;j < books[i].length;j++){
                System.out.println(books[i][j]);
            }
        }

        System.out.println("----------二维数组的foreach遍历------------");
        for(String[] str:books){
            for (String book:str){
                System.out.println(book);
            }
        }
    }
}

6.3 案例（杨辉三角）

代码示例：

package com.qf.ran.array;

/**
 * @author wzy
 * @since JDK 1.8
 *          杨辉三角
 *          1.列数与行数相等
 *          2.每一行的第一个数与最后一个数为1
 *          3.除了首尾的其他数字，等于他上一行的数与上一行前一列的数相加。
 *
 *          1
 *          1   1
 *          1   2   1
 *          1   3   3   1
 *          1   4   6   4   1
 *          1   5   10  10  5   1
 */
public class Demo06 {
    public static void main(String[] args) {
        print(9);
    }

    //打印杨辉三角
    public static void print(int num){
        //行数与列数一样
        int[][] nums = new int[num][num];
        //控制的是行数
        for (int i = 0; i < nums.length; i++) {
            //控制列数
            for (int j = 0; j <= i; j++) {
                //第一列或者每列与行数相同的数设为1
                if(j == 0 || i == j){
                    nums[i][j] = 1;
                }else{
                    //其他数则等于上一行同列的数加上一行前一列的数
                    nums[i][j] = nums[i-1][j]+nums[i-1][j-1];
                }

                //打印
                System.out.print(nums[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

7、数组排序

7.1 冒泡排序

冒泡排序：相邻的两个数值比较大小，互换位置。
代码示例：

package com.qf.ran.sort;

import java.util.Arrays;

/**
 * @author Ran
 * @since JDK 1.8
 *
 *          排序算法:
 *              冒泡排序
 *                  相邻的两个数进行两两对比，符合条件的数进行交换
 *              快速排序
 *              插入排序
 *              归并排序
 *              希尔排序
 *              选择排序
 *                   一轮比较中多次比较选出最小值或者最大值，进行一次交换
 *              桶排序
 *              堆排序
 *              计数排序
 *              基数排序
 */
public class Demo01 {
    public static void main(String[] args) {
        int[] nums = {3, 1, 5, 2};

        //外层for循环控制的是轮数     nums.length-1的原因是因为最后一个数不需要进行位置确定
        for(int j = 0;j < nums.length-1;j++){
            //内层for循环控制的是每轮对比的次数
            // nums.length-j的原因是因为每轮会少一个需要比较的值
            //减一的原因是因为轮数是由j控制，j从0开始
            for (int i = 0; i < nums.length-j-1; i++) {
                if (nums[i] > nums[i + 1]) {
                    int temp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));


        //-------------第一轮-------------
        /*for (int i = 0; i < 3; i++) {
            if (nums[i] > nums[i + 1]) {
                int temp = nums[i];
                nums[i] = nums[i + 1];
                nums[i + 1] = temp;
            }
        }

        //-------------第二轮-------------
        for (int i = 0;i < 2;i++){
            if (nums[i] > nums[i + 1]) {
                int temp = nums[i];
                nums[i] = nums[i + 1];
                nums[i + 1] = temp;
            }
        }

        //-------------第三轮-------------
        for(int i = 0;i < 1;i++){
            if (nums[i] > nums[i + 1]) {
                int temp = nums[i];
                nums[i] = nums[i + 1];
                nums[i + 1] = temp;
            }
        }*/

        //-------------第一轮-------------
        //第一次   --  第一个数与第二个数进行比较
        /*if(nums[0] > nums[1]){
            int temp = nums[0];
            nums[0] = nums[1];
            nums[1] = temp;
        }
        //第二次   --  第二个数与第三个数进行比较
        if(nums[1] > nums[2]){
            int temp = nums[1];
            nums[1] = nums[2];
            nums[2] = temp;
        }
        //第三次   --  第三个数与第四个数进行比较
        if(nums[2] >nums[3]){
            int temp = nums[2];
            nums[2] = nums[3];
            nums[3] = temp;
        }*/

        //-------------第二轮-------------
        //第一次   --  第一个数与第二个数进行比较
        /*if(nums[0] > nums[1]){
            int temp = nums[0];
            nums[0] = nums[1];
            nums[1] = temp;
        }
        //第二次   --  第二个数与第三个数进行比较
        if(nums[1] > nums[2]){
            int temp = nums[1];
            nums[1] = nums[2];
            nums[2] = temp;
        } */

        //---------------第三轮------------
        //第一次   --  第一个数与第二个数进行比较
        /*if(nums[0] > nums[1]){
            int temp = nums[0];
            nums[0] = nums[1];
            nums[1] = temp;
        }*/
    }
}

7.2 选择排序

选择排序：一轮比较中多次比较选出最小值或者最大值，进行一次交换
代码示例：

package com.qf.ran.sort;

/**
 * @author Ran
 * @since JDK 1.8
 */
public class Demo02 {
    public static void main(String[] args) {
        int[] nums = {3,1,5,2};
        //外层for循环控制轮数
        for(int i = 0;i <nums.length - 1;i++){
            //1.定义min的初始值
            int min = i;
            //2.j为被对比数的索引
            for(int j = i+1;j < nums.length;j++){
                //nums[min]为对比数,nums[j]为被对比数
                if(nums[min] > nums[j]){
                    //改变min的索引为被对比数的索引
                    min = j;
                }
            }
            //3.判断min是否为初始值
            if(min != i){
                int temp = nums[min];
                nums[min] = nums[i];
                nums[i] = temp;
            }
        }
    }
}

wzyyj

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
java day06 数组（一维数组、二维数组、可变参数）

1、数组概念1.1 数组概念为什么要用数组存储相同的100个学生的名字，需要2、数组的声明和赋值2.1 声明2.2 赋值3、数组的组成3.1 组成3.2 如何使用4、数组的遍历4.1 for循环4.2 foreach循环（增强for循环）5、可变参数6、二维数组6.1 概念、创建6.2 遍历6.3 案例（杨辉三角）7、数组排序7.1 冒泡排序7.2 选择排序...
复制链接

扫一扫