首页 > 编程语言 >Java学习——数组

Java学习——数组

时间：2023-07-02 12:24:07浏览次数：55  
标签：Java int System 学习 arrays 数组 println out

数组

一、数组的定义

Java 语言中提供的数组是用来存储固定大小的同类型元素。

二、数组声明和创建

1.声明数组变量

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar;   // 首选的方法
 
或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

int[] nums;//定义数组方法1 首选方法
int nums2[];//定义数组方法2

2.创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

		int[] nums;//定义数组方法1 首选方法
        nums = new int[10];//创建一个数组 开辟10个空间大小

		//声明和创建写在一起
		int nums[]=new int[10];

        //给数组元素赋值
        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;
        System.out.println(nums[9]);//没有赋值 默认返回int默认的0
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println("总和为"+sum);
    }

3.数组元素是通过索引来访问的，且索引值从0开始

4.获取数组长度 arrays.length

三、三种初始化

public static void main(String[] args) {
        //1.静态初始化
        //创建+赋值
        int [] num={1,2,3,4,5};

        //2.动态初始化
    	//包含默认初始化
        int [] num2=new int[10];
        num2[0]=10;
        System.out.println(num[0]);//1
        System.out.println(num2[1]);//没有赋值的默认也是0
        System.out.println(num2[2]);//没有赋值的默认也是0
        System.out.println(num2[3]);//没有赋值的默认也是0
    }

四、数组的4个基本特点

  • 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
  • 其元素必须是相同类型,不允许出现混合类型。
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
  • 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型数组对象本身是在堆中的。

异常：java.lang.ArrayIndexOutOfBoundsException: 10——>数组下标越界

五、数组使用

1.普通用法

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 = sum + arrays[i];
        }
        System.out.println("总和为：" + sum);
        System.out.println("==============================");
        //最大值
        int max = arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i] > max) {
                max = arrays[i];
            }
        }
        System.out.println("最大值为："+max);
    }

2.进阶用法 for..each

public static void main(String[] args) {
        int [] arrays={10,20,30,40,50};
        for (int array : arrays) {//增强型for循环 没有下标
            System.out.println(array);
        }
    }
//输出
10
20
30
40
50


public static void main(String[] args) {
        int[] arrays = {10, 20, 30, 40, 50};
        for (int array : arrays) {//增强型for循环 没有下标
            System.out.println(array);
        }
        System.out.println("==============================");

        printArray(arrays);//打印数组元素
        System.out.println("");
        
        int[] reverse = reverse(arrays);//反转数组
        printArray(reverse);
    }

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

    //反转数组
    public static int[] reverse(int[] arrays) {
        int[] result = new int[arrays.length];
        //反转的操作
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }
        return result;
    }
//运行结果
10
20
30
40
50
==============================
10 20 30 40 50 
50 40 30 20 10 
Process finished with exit code 0

六、二维数组

public static void main(String[] args) {
        int[][] array = {{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}};
        System.out.println(array[0][0]);//1
        System.out.println(array[0][1]);//2
        System.out.println(array.length);//5
        System.out.println(array[0].length);//2{1,2}
        System.out.println("=============================");
        //遍历多维数组
        for (int i = 0; i <array.length ; i++) {
            for(int j=0;j<array[i].length;j++){
                System.out.println(array[i][j]);
            }
        }
    }
//运行结果
1252=============================
12345678910

七、Arrays 类讲解

  1. 数组的工具类java.util.Arrays
    由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,

    从而可以对数据对象进行一些基本的操作。

  2. 查看JDK帮助文档
    Arrays类中的方法都是static修饰的静态方法在使用的时候可以直接使用类名进行调用,而”不用”使用对象来调用(注意:是”不用”而不是”不能”)

  3. 具有以下常用功能:

  • 给数组赋值:通过 fill方法
  • 对数组排序:通过sort 方法,按升序
  • 比较数组:通过equals 方法比较数组中元素值是否相等
  • 查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作
import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {2, 78, 4, 32, 34, 66, 8, 0};
        System.out.println(a);//[I@1540e19d输出hashcode码
        //打印数组元素
        System.out.println(Arrays.toString(a));//[2, 78, 4, 32, 34, 66, 8, 0]
        print(a);
        System.out.println("==================================");
        //对数组进行排序  升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println("====================================");
        //fill填充
        Arrays.fill(a ,2, 4, 0);//用0进行填充(2——3填充为0)
        System.out.println(Arrays.toString(a));
    }

    public static void print(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (i == 0) {
                System.out.print("[");
            }
            if (i == a.length - 1) {
                System.out.println(a[i] + "]");
            } else {
                System.out.print(a[i] + ",");
            }
        }
    }
}
//运行结果
[I@1540e19d
[2, 78, 4, 32, 34, 66, 8, 0]
[2,78,4,32,34,66,8,0]
==================================
[0, 2, 4, 8, 32, 34, 66, 78]
====================================
[0, 2, 0, 0, 32, 34, 66, 78]

八、冒泡排序

总共有八大排序!冒泡排序无疑是最为出名的排序算法之一
冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知。
我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)。

冒泡排序

  1. 比较数组中，两个相邻的元素，如果第一个比第二个数大，就交换他们的位置
  2. 每一次比较，都会产生一个最大，或者最小的数字
  3. 下一轮则可以少一次排序
  4. 依次循环，直到结束

交换两个数的位置，需要借助第三方变量

public static void main(String[] args) {
        int[] a = {22, 45, 3, 45, 67, 77, 5, 79, 100};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array) {
        //临时变量 第三方变量
        int temp = 0;
        boolean flag = false;//通过flag标识位，减少没有意义的比较
        //外层循环  判断要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环 比较判断两个数 如果第一个数比第二个数大，则交换位置
            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;
    }

九、稀疏数组



public class ArrayDemo08 {
    public static void main(String[] args) {
        //创建一个二维数组 当作棋盘11*11 0:没有棋子 1：黑棋  2：白棋
        int[][] a1 = new int[11][11];//11*11的棋盘
        a1[1][2] = 1;
        a1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组：");
        for (int[] ints : a1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        //转换为稀疏数组来保存
        //1.获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (a1[i][j] != 0) {
                    sum++;
                }
            }
        }
        //输出有效值的个数
        System.out.println("有效值的个数为：" + sum);
        System.out.println("==============================s");
        //2.创建一个稀疏数组
        int[][] a2 = new int[sum + 1][3];//行列
        //稀疏数组的头部 行、列、有效值个数
        a2[0][0] = 11;//0行0列
        a2[0][1] = 11;//0列1列
        a2[0][2] = sum;//0列2列 有效值的个数
        //遍历二维数组，将非零的值存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
                if (a1[i][j] != 0) {
                    count++;
                    a2[count][0] = i;
                    a2[count][1] = j;
                    a2[count][2] = a1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组：");
        for (int i = 0; i < a2.length; i++) {
            System.out.println(a2[i][0] + "\t"
                    + a2[i][1] + "\t"
                    + a2[i][2] + "\t");
        }
        System.out.println("==============================");
        System.out.println("还原成普通数组：");
        //1.读取稀疏数组
        int[][] a3 = new int[a2[0][0]][a2[0][1]];//稀疏数组的前两个数字

        //2.给其中的元素还原值
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][1]] = a2[i][2];
        }
        //输出还原的数组
        System.out.println("输出还原数组：");
        for (int[] ints : a3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

好难啊 计算机真的适合我吗？我真的会吗？一点都记不住 sad........

标签：Java,int,System,学习,arrays,数组,println,out
From： https://www.cnblogs.com/feifei-study/p/17520587.html

相关文章

  • Java主流jdk发行版有哪些?
    Java的特点是百花齐放，不像c#或者go只有一家主导。oraclejdk收费了，没关系，不是只有它可用。java还有很多免费的主流的jdk发行版，记录下来备忘。OpenJDK-官方网站-源代码-文档-下载地址OpenJDK是其他所有jdk发行版的基础，可以用于开发和测试，但不建议将它用于Java生产环......
  • java.net.BindException: Address already in use: JVM_Bind <null> 的解决方案
    问题描述在学习SSM整合中，启用Tomcat插件时出现以下错误java.net.BindException:Addressalreadyinuse:JVM_Bind<null>通过查阅资料发现是端口被占用了解决方案通过命令查看进程，这里我的是8080端口号被占用了netstat-ano再运行命令去杀死占用端口进程taskk......
  • atx-agent学习(3)-安装uiautomator apk
    源码如下:def_install_uiautomator_apks(self):"""useuiautomator2.0torunuiautomatortest通常在连接USB数据线的情况下调用"""self.shell("pm","uninstall","com.github.uiautomator&q......
  • java中NaN是什么意思
    NaN，是NotaNumber的缩写。NaN用于处理计算中出现的错误情况，比如0.0除以0.0或者求负数的平方根。由上面的表中可以看出，对于单精度浮点数，NaN表示为指数为emax+1=128（指数域全为1），且尾数域不等于零的浮点数。IEEE标准没有要求具体的尾数域，所以NaN实际上不是一个，而是......
  • SpringCloud学习(四)
    参考:https://blog.csdn.net/qq_25928447/article/details/124340264?spm=1001.2014.3001.5501消息队列之前如果需要进行远程调用，一般可以通过发送HTTP请求来完成，现在，可以使用第二种方式，就是消息队列，它能够将发送方发送的信息放入队列中，当新的消息入队时，会通知接收方进行处理......
  • 验证码生成技术的学习总结(C#)
    作者：光脚丫思考 一、概述一直以来对于验证码这玩意都是使用了别人编写好的代码，最多也就是稍微的做点修改罢了。虽然别人做的东西并不是非常的适合自己使用，但还是给将就将就了一番。这几天呢？不知道是哪里高兴了，终于是好好的把一些别人早就已经使用过的验证码技术给好好的拿来学习学......
  • GeoServer入门学习：05-多层级MBTiles规范数据发布
    一、开篇本篇演示如何在GeoServer中发布多层级的MBTiles数据，在发布之前，需要配置MBTiles扩展包，如果没有配置WPS扩展包的话，还需要配置一并进行配置。如上图所示，默认情况下GeoServer并未包含MBTiles扩展包，因此，在《新建数据源》的时候是没有发布MBTiles数据的入口。 二、下载WPS扩展包......
  • GeoServer入门学习：02-安装部署
    一、系统环境本系列博文相关演示环境采用如下操作系统环境：这是在虚拟机中安装的WindowsServer2012R2的操作系统，其他系统环境大家自行尝试。二、安装JDKJDK版本：JDK13，如下图所示：GeoServer是基于Java的软件，运行的时候需要JDK的支持，如果你的系统中没有安装配置好JDK，请按照下面的这......
  • pytorch的学习
    三种编译方式的优缺点 Pytroch中的加载数据主要涉及了两个类，一个叫Dataset,一个叫Dataloader.举一个不恰当的例子，我们要在诸多的垃圾(数据)中找到我们所需要的垃圾(数据)，Dataset就是将其中的可回收垃圾提取出来，并且将它们进行编号，同时可以根据编号获取相对应的垃圾，同时获取相......
  • PMP学习笔记（五）
    06.20星期二 项目进度网络图 员工激励：拖延症和帕金森定律。减少估算时间和磨洋工的机会 计算期望时间，默认是贝塔分布 搞清楚关键路径：总是差=0 总浮时：在不影响整体时间的前提下可以推迟的时间；自由浮时：在不影响后一个任务的启动日期的前提下可以推迟的时间 重要干系人发生变化，应首......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99