JavaSE05

于 2024-09-09 23:01:46 发布
阅读量155 收藏 4
点赞数 1
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2403_87004789/article/details/142071548
版权

Java数组

数组的定义

image-20240908234506677

数组的声明和创建

image-20240909124802319

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] nums; //1.声明一个数组
        nums = new int[10]; //2.创建一个数组
        int[] nums2 = new int[10];  //声明创建写一起

        //3.给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;

        //计算所有元素的和
        int sum = 0;

        //获取数组长度：arrays.length
        for (int i = 0; i < nums.length ; i++) {
            sum = sum + nums[i];
        }
        System.out.println("总和为：" + sum);
    }
}

内存分析

image-20240909143644317

image-20240909143758103

三种初始化

数组的默认初始化：数组是引用类型，它的元素相当于是类的实例变量
因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int [] a = {1,2,3,4,5,6,7,8};
        System.out.println(a[0]);

        //动态初始化：包含默认初始化
        int[] b = new int[10];
        b[0] = 10;
        b[1] = 10;

        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
    }
}

数组的四个基本特点

image-20240909152738910

数组边界

image-20240909152921635
image-20240909152945408

数组的使用

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //打印全部的数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("=========================");
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        System.out.println("sum=" + sum);
        System.out.println("=========================");
        //查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (max < arrays[i]) {
                max = arrays[i];
            }
        }
        System.out.println("max=" + max);
        System.out.println("=========================");
    }
}

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //JDK1.5，没有下标
        //For-Each循环
        for (int array : arrays) {
            System.out.println(array);
        }
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    //反转数组：数组作返回值
    public static int[] reverse(int[] arrays) {
        int[] result = new int[arrays.length];
        for (int i = 0, j = arrays.length-1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }
        return result;
    }

    //打印数组元素：数组作方法入参
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

public class ArrayDemo05 {
    public static void main(String[] args) {
        //[4][2]
        /*
        1,2     array[0]
        2,3     array[1]
        3,4     array[2]
        4,5     array[3]
         */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};

        printArray(array[0]);
        System.out.println(array[2][1]);
        System.out.println(array.length);
        System.out.println(array[0].length);
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }

    //打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

Arrays类讲解

image-20240909204313964

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {2,321,3123,432,5435,76546,42342,3,67,23};
        System.out.println(a);  //[I@1b6d3586

        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));
        printArray(a);

        Arrays.sort(a); //对数组进行排序：升序
        System.out.println(Arrays.toString(a));

        Arrays.fill(a, 2, 4, 0); //数组填充
        System.out.println(Arrays.toString(a));
    }

    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (i == 0) {
                System.out.print("[");
            }
            if (i == a.length-1) {
                System.out.print(a[i] + "]");
            } else {
                System.out.print(a[i] + ", ");
            }
        }
    }
}

冒泡排序

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {2,32,32,453,5412,131,323,63};
        int[] sort = sort(a);   //调用排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;
        //外层循环：判断要走多少次
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false;   //通过flag标识位减少没有意义的比较

            //内层循环：比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag==false) {
                break;
            }
        }
        return array;
    }
}

稀疏数组

image-20240909225345305

public class ArrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11   0：没有棋子  1：黑棋    2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("=======================");

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数：" + sum);

        //2.创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值存放稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2]);
        }
        System.out.println("=======================");

        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //3.打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}
acbliss
关注
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
STL array方法总结(二)Capacity和Modifiers（21）
roaylchen的博客
08-30 1044
这里是array方法的一些总结，具体的可以看后面的链接： public member function std::array::size constexpr size_type size() noexcept; 返回array里面元素的数目。 Parameters none Return Value array中元素的数目。
数组.array
qq_54803395的博客
05-05 166
01 package com.kuang.array; public class ArrayDemo01 { //变量的类型(数组类型) 变量的名字 = 变量的值; public static void main(String[] args) { int[] nums;//1.声明一个数组(定义) int nums2[];//为了让c程序员适应而衍生的方式 nums=new int[10];//2.创建一个数组(这里面可以存
Java中数组的定义与使用(三)
jarniyy的博客
01-17 180
数组排序 在很多的面试题上都会出现数组排序的操作形式。但是这个时候你千万别写上：java.util.Arrays.sort(数组)。而这种排序都是以升序为主。 基础的排序操作： 范例： 冒泡排序 public class ArrayDemo { public static void main(String args[]) { int data[] = new int[] {9, 3, 1, 5, 4, 2, 7, 8, 6, 0}; sort(data); ...
数组的概述
qq_45608338的博客
10-17 238
3.1 数组的概述 /* 一、数组的概述 1.数组的理解：数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名， 并通过编号的方式对这些数据进行统一管理。 2.数组相关的概念： 数组名 元素 角标、下标、索引 数组的长度：元素的个数 3.数组的特点： 1）数组是有序排列的 2）数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 3）创建数组对象会在内存中开辟一整块连续的空间 4）数组的长度一旦确定，就不能修改。
Java中数组的定义与使用(二)
mrbacker的博客
09-01 5111
数组与方法调用 数组是一个引用数据类型，那么所有的引用数据类型都可以为其设置多个栈内存指向。所以在进行数组操作的时候，也可以将其通过方法进行处理。 范例：方法接受数组 public class ArrayDemo { public static void main(String args[]) { int data[] = new int[] {1, 2,...
javase05(第六章)
qq_63240481的博客
10-22 2206
javase05
JavaSE 05 方法
loetca
03-27 2096
JavaSE 05 方法
就业班JavaSE--day05 每日作业卷1
08-08
JavaSE的第五天作业主要涵盖了Java基础中的几个关键知识点，包括`Object`类、`equals()`方法、`toString()`方法、异常处理以及错误和异常的区别。以下是对这些知识点的详细说明： 1. **Object类**： - `Object`类...
Java学习笔记3（数组）
weixin_30338497的博客
01-05 129
1.数组的定义： 第一种： public class ArrayDemo{ 　　public static void main(String[] args){ 　　//定义数组 　　int [] arr = new int[3]; 　　//数组中的元素默认值为0 　　System.out.println(arr[0]); 　　System.out.println(arr.length...
基于Matlab实现粒子群（PSO）算法案例（附上20个案例源码）
最新发布
m0_62143653的博客
04-10 2万+
基于Matlab实现粒子群（PSO）算法案例（附上20个案例源码）
【运筹优化】PSO粒子群算法求解无约束多元函数最值(Java代码实现)
热门推荐
知不足而奋进，望远山而前行
06-06 2万+
粒子群优化算法(Particle Swarm optimization,PSO)又翻译为粒子群算法、微粒群算法、或微粒群优化算法。是通过模拟鸟群觅食行为而发展起来的一种基于群体协作的随机搜索算法。通常认为它是群集智能 (Swarm intelligence, SI) 的一种。它可以被纳入多主体优化系统(Multiagent Optimization System, MAOS)。粒子群优化算法是由Eberhart博士和kennedy博士发明。PSO模拟鸟群的捕食行为。一群鸟在随机搜索食物，在这个区域里只有一块
粒子群算法(PSO)——Java实现PSO算法(详细注释) 优化算法
cccddduil的博客
03-22 2419
https://blog.csdn.net/daaikuaichuan/article/details/81382794https://blog.csdn.net/daaikuaichuan/article/details/81382794代码||注释||结果 package PSO; /* * Target function : F(x, y) = x^2 + y^2; * Opti Solution is F(0, 0) = 0, Certainly; * * According to
粒子群java
Liang_1_的博客
02-21 98
package PSO; /* * Target function : F(x, y) = x^2 + y^2; * Opti Solution is F(0, 0) = 0, Certainly; * * According to PSO * * v' = w * v + c1 * rand() * (localbest - x) + c2 * rand() * (globalbest - x); * x' = x + v'; * * In our case, c1 = c2
蚁群优化算法的JAVA实现_优化算法|蚁群算法的理解及实现
weixin_39613692的博客
02-27 592
蚁群算法1. 蚁群算法基本原理蚁群算法(Ant Colony Algorithm, ACA)由Marco Dorigo于1992年提出。蚁群原理：蚁群算法的基本原理来源于自然界觅食的最短路径原理。根据昆虫学家的观察，蚂蚁可以在没有任何提示的情况下找到从食物源到巢穴的最短路径，并且能在环境发生变化(如原有路径上有了障碍物)后,自适应地搜索新的最佳路径。蚂蚁是怎么做到这一点的呢？蚁群算法有自己的优化策...
粒子群算法（PSO）——Java实现
厉兵秣码
07-06 6405
粒子群算法是计算算法的一种，1995年由Eberhart 博士和kennedy 博士提出，源于对鸟群捕食的行为研究 。 该算法利用群体中的个体对信息的共享使整个群体的运动在问题求解空间中产生从无序到有序的演化过程，从而获得最优解。 试想一下，如果一群鸟在一片区域中寻找食物，所有的鸟都不知道食物在什么地方，但是每一只鸟都知道自己距离食物有多远，也知道这一群鸟中离食物最近的鸟在什么位置，这样每一只...
粒子群优化算法的JAVA实现
FashionXu的专栏
05-20 8340
说明：算法为了演示功能，所以没有优化，没有异常处理等，仅作演示用。/* * To change this template, choose Tools | Templates * and open the template in the editor. */import java.util.Random;/** *粒子类 * 求解函数 f(x)=x1^2+(x2-x
粒子群算法组卷_一种改进的多目标粒子群组卷算法
weixin_42097208的博客
02-12 455
利用计算机按照一定的组卷算法从试题库抽取试题组成符合要求的试卷,是实现考试规范化和科学化的手段。在各种计算机辅助考试系统、试题库系统软件中,自动组卷一直是该类系统的一个难点,其解决方法也一直是算法研究热点。可以说一个自动组卷系统的效率和组卷质量主要取决于组卷算法。以往的组卷算法多采用随机抽题法、回溯试探法及遗传算法。随机抽题法根据状态空间的控制指标,随机抽选一道试题加入试卷中,不断重复直到组卷完毕...
JavaSE day05异常与Object类深度解析
"JavaSE的学习内容，包括异常处理、Object类的方法（equals和toString）以及错误和异常的区分和处理" 在Java编程中，Object类是所有类的根类，这意味着所有的类都直接或间接地继承自Object。Object类位于继承层次...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值