带你粗略了解Java数组的使用

目录
  • 数组的定义
    • 注意:
  • 数组的创建及初始化:
    • 1.数组的创建:
    • 2.数组的初始化
      • ①动态初始化:
      • ②静态初始化:
    • 注意事项:
  • 数组的使用
    • 1.数组的长度:
    • 2.数组的访问:
    • 3.数组的遍历:
    • 4.使用数组交换两个整数
    • 5.以字符串的形式输出数组:
  • 理解引用类型:
    • 1.基本类型变量与引用类型变量的区别
    • 2.认识null
    • 3.数组作为方法的返回值
  • 二维数组:
    • 1.创建二维数组及初始化:
    • 2.二维数组长度:
    • 3.二维数组的打印:
    • 4.不规则的二维数组:
  • Array类:
  • 总结

数组的定义

数组:可以看作相同类型元素的一个集合,且在内存中是一块连续的内存空间

注意:

C语言中,数组的内存在栈上

在Java中,数组的内存在堆上

数组的创建及初始化:

1.数组的创建:

基本语法格式:

T[ ] 数组名 = new T[N];
.
① T,即Type,表示:数组中存放元素的类
② T[ ], 表示:数组的类型
③ N, 表示:数组的长度

举例:

创建一个可以容纳10个int类型元素的数组
int[] array1 = new int[10];
创建一个可以容纳5个double类型元素的数组
double[] array2 = new double[5];

2.数组的初始化

数组的初始化主要分为动态初始化和静态初始化

①动态初始化:

基本语法格式:

int[ ] array = new int[10]
在创建数组时,直接指定数组中元素的个数

②静态初始化:

基本语法格式:

int[ ] array1 = new int[ ] {0,1,2,3,4,5,6};
double[ ] array2 = new double[ ]{1.0, 2.0, 3.0, 4.0,5.0};

注意事项:

  • 如果没有对数组进行初始化,数组中元素有其默认值

如果数组中存储元素类型为基类类型,默认值为基类类型对应的默认值

如果数组中存储元素类型为引用类型,默认值为null

  • 静态初始化无需指定数组的长度,编译器在编译时会根据{ }中元素个数来确定数组的长度
  • 静态初始化时,{ }中数据类型必须与[ ]前数据类型一致、
  • 静态初始化可以简写,省去后面的new T[ ]
  • 如果不确定数组当中内容时,使用动态初始化,否则建议使用静态态初始化

数组的使用

1.数组的长度:

数组的长度属性: 每个数组都具有长度,而且是固定的,Java中赋予了数组的一个属性,可以获取到数组的长度,语句为:数组名.length

int[ ] array = new int[ ]{1,2,3,4,5,6};
int len = array.length;
此处的 length 是属性

2.数组的访问:

数组在内存中是一段连续的空间,空间的编号都是从0开始的,依次递增,该编号称为数组的下标,数组可以通过下标访问其任意位置的元素

索引:每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编号称为数组索引 (index),可以通过数组的索引访问到数组中的元素
由数组的长度知,属性 length 的执行结果是数组的长度,int类型结果,则数组的最大索引值为数组名.length-1

格式:
数组名[索引]

数组名[索引] = 数值,为数组中的元素赋值变量 = 数组名[索引],获取出数组中的元素

public static void main(String[] args) {
	//定义存储int类型数组,赋值元素1,2,3,4,5
	int[] arr = {1,2,3,4,5};
	//为0索引元素赋值为6
	arr[0] = 6;
	//获取数组0索引上的元素
	int i = arr[0];
	System.out.println(i);
	//直接输出数组0索引元素
	System.out.println(arr[0]);
}

注意事项:

  • 数组是一段连续的内容空间,因此支持随机访问,即通过下标访问快速访问数组中任意位置的元素
  • 下标从0开始,介于[0, N) 之间不包含N,N为元素个数,不能越界,否则会报出下标越界异常

3.数组的遍历:

“遍历”:是指将数组中的所有元素都访问一遍

这里用打印的方式展示遍历:

int[] array = new int[]{1,2,3,4,5,6};
int len = array.length;
for(int i=0;i<len;i++){
	System.out.println(array[i]);
}

延申:

Java中的打印方式,出了上述的,还有foreach,即:for( 遍历的数组内容 :数组本身)

代码如下:

for (int val:array) {
	System.out.println(val+" ");
}

二者区别:

for循环遍历打印数组,需要索引,而foreach不需要,若单纯的想要遍历数组,用foreach即可

4.使用数组交换两个整数

//使用数组实现交换两个整数
    public static void swap(int[] array){
	    int tmp = array[0];
	    array[0] = array[1];
	    array[1] = tmp;
    }
    public static void main(String[] args) {
        int[] array1 = {10,20};
        System.out.println("交换前:"+array1[0]+" "+array1[1]);
        swap(array1);
        System.out.println("交换后:"+array1[0]+" "+array1[1]);
    }

输出结果:
交换前:10 20
交换后:20 10

交换原理:

5.以字符串的形式输出数组:

使用方法toString 需要调用包 java.util.Arrays

int[] arr = {1,2,3,4,5,6};
String ret = Arrays.toString(arr);
System.out.println(ret);

理解引用类型:

1.基本类型变量与引用类型变量的区别

基本数据类型创建的变量,称为基本变量,该变量空间中直接存放的是其所对应的值;
引用数据类型创建的变量,一般称为对象的引用,其空间中存储的是对象所在空间的地址

public static void func() {
	 int a = 10;
	 int b = 20;
	 int[] arr = new int[]{1,2,3};
}

在上述代码中:a,b,arr,都是函数内部的变量,因此其空间都在main方法对应的栈帧中分配;

a、b是内置类型的变量,因此其空间中保存的就是给该变量初始化的值。

array是数组类型的引用变量,因为都为引用其内部保存的是数组在堆空间中的首地址

引用变量并不直接存储对象本身,而存储的是对象在堆中空间的起始地址,通过该地址,引用变量便可以去操作对象。有点类似C语言中的指针,但是Java中引用要比指针的操作更简单

2.认识null

null 在 Java 中表示 “空引用”,也就是一个不指向对象的引用,即:空对象

int[ ] arr = null; //arr引用的是一个空对象
System.out.println(arr[0]);
此处不能访问0下标,因为没有所指对象

null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置,因此不能对这个内存进行任何读写操作,Java 中并没有约定 null 和 0 号地址的内存有任何关联

3.数组作为方法的返回值

将一个数组内容扩大二倍:

public static int[] fun(int[] array){
	int[] tmp = new int[array.length];
	for (int i = 0; i <array.length; i++) {
	    tmp[i] = array[i] * 2;
}
	return tmp;
}
public static void main(String[] args) {
	int[] array = {1,2,3,4,5,6,7,8};
	int[] ret = fun(array);
	System.out.println(Arrays.toString(ret));
}

二维数组:

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组

即:数组的数组就是一个二维数组

语法格式:
数据类型[ ][ ] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

1.创建二维数组及初始化:

int[][] array1 = new int[10][10];
int array2[][] = new int[10][10];
int array3[][] = { { 1, 1, 1 }, { 2, 2, 2 } };
int array4[][] = new int[][] { { 1, 1, 1 }, { 2, 2, 2 } };

2.二维数组长度:

// 获取二维数组的第一维长度(3)
int len1 = array.length;
// 获取二维数组的第一维的第一个数组长度(1)
int len2 = array[0].length;

进行开发之中,出现二位数组的几率并不高

3.二维数组的打印:

  • 方法① foreach
int[][] array = { {1,2,3}, {4,5,6} };
	for (int[] tmp : array) {
		for (int x: tmp) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
  • 方法② for循环
for (int i = 0; i < array.length; i++) {
	for (int j = 0; j < array[i].length; j++) {
		System.out.print(array[i][j]+" ");
	}
	System.out.println();
}

打印结果:

  • 方法③ deeptoString
int[][] array = {{1, 2, 3}, {4, 5, 6}};
System.out.println(Arrays.deepToString(array));

打印结果:

4.不规则的二维数组:

int[ ][ ] array = new int[2][ ];

注意:C语言中是可以指定列,行可自行推导;Java中,行必须指定,列是不可以自动推导的

此时若用上述 for 循环来打印数组,便会出现异常:

分析如下:

Array类:

java.util.Arrays 类提供的所有方法都是静态的,能方便地操作数组,

由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。

Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用 (注意:是"不用"而不是"不能")

Array具有的功能这里就不一一列举了,可以去JDK帮助文档自行了解

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • java数据结构基础:稀疏数组

    目录 稀疏数组: 实现思路: 举例: 二维数组转稀疏数组实现思路: 稀疏数组恢复二维数组实现思路: 代码实现: 输出结果: 总结 稀疏数组: 当一个二维数组中大部份的值为0,或者为同一值的时候,可以用稀疏数组来保存 实现思路: 记录二维数组有多少行多少列.多少个不同的值 把不同的值按照所在行列,记录在一个规模较小的数组中 举例: 11×11的二维数组: 对应的稀疏数组: 其中,第一行分别为,原二维数组总行数.总列数.不为0的数的个数 之后几行的每一列分别代表所在行.所在列.值 二维数组转稀疏数组

  • java简单实现数组的增删改查方法

    目录 1.一维数组​ 2.数组的扩容 3.数组的复制 1.直接将数组赋值给新数组 2.创建一个新的数组,再将原数组的数据逐个赋值 4.数组的删除 5.数组的排序 6.数组的查找 1.顺序查找:从头到尾遍历(简单除暴,效率相对较低) 2.二分法查找 总结 1.一维数组​ 概念:一组数据的容器(数组可以存放多个数据) ​ 注意: ​ 1.数组是引用数据类型 ​ 2.数组中的数据又叫做元素 ​ 3.每个元素都有编号叫做下标/索引 ​ 4.下标从0开始 ​ 5.数组初始化后,会在内存中开辟一连串连续的空

  • Java数组的运用详解

    目录 一,数组的含义: 二,数组的创建 1,动态初始化 2,静态初始化 三,数组遍历 四,Arrays.deepToString()与Arrays.toString()的区别 五,Java中Arrays类的常用方法 1,数字排序 2,字符串排序,先大写后小写 3,严格按字母表顺序排序,也就是忽略大小写排序 CASE_INSENSITIVE_ORDER 4,反向排序, Collections.reverseOrder() 5,忽略大小写反向排序 (先忽略大小写,再反向排序) 6,选择数组指定位置进

  • java实现动态数组

    本文实例为大家分享了java实现动态数组的具体代码,供大家参考,具体内容如下 数组最大的优点︰快速查询.scores[2].数组最好应用于"索引有语意"的情况,但是如果索引比较长就还是不要用数组了,比如身份证号,太长了. Java提供给我们的数组是静态数组,大小在一开始就定下来了,所以我们要创建一个动态数组,来满足我们的需求.其实原理挺简单,初次创建的时候赋予一个初始大小,当容量不够用时进行扩容,下列代码最关键的是resize方法 public class Array<E>

  • Java实战小技巧之数组与list互转

    目录 前言 I. 数组转 List 1. Array.asList 1.1 知识点 2. new ArrayList 2.1 避雷预警 3. Collections.addAll II. 列表转数组 III. 小结 总结 前言 这个考题比较常见,也比较简单,难道就这也有什么可以说到的门路不成? 接下来本文好好的说一说它的几种实现姿势,总有一款你喜欢的 I. 数组转 List 1. Array.asList 这个考题太简单了,直接使用Array.asList不就完事了么,比如 @Test publ

  • 带你粗略了解Java数组的使用

    目录 数组的定义 注意: 数组的创建及初始化: 1.数组的创建: 2.数组的初始化 ①动态初始化: ②静态初始化: 注意事项: 数组的使用 1.数组的长度: 2.数组的访问: 3.数组的遍历: 4.使用数组交换两个整数 5.以字符串的形式输出数组: 理解引用类型: 1.基本类型变量与引用类型变量的区别 2.认识null 3.数组作为方法的返回值 二维数组: 1.创建二维数组及初始化: 2.二维数组长度: 3.二维数组的打印: 4.不规则的二维数组: Array类: 总结 数组的定义 数组:可以看

  • 一文带你深入了解Java泛型

    目录 什么是Java泛型 泛型的使用 泛型类 泛型接口 泛型方法 泛型的底层实现机制 ArrayList源码解析 什么是泛型擦除 泛型的边界 ?:无界通配符 extends 上边界通配符 super 下边界通配符 PECS原则 泛型是怎么擦除的 擦除类定义中的无限制类型参数 擦除类定义中的有限制类型擦除 擦除方法定义中的类型参数 桥接方法和泛型的多态 泛型擦除带来的限制与局限 泛型不适用基本数据类型 无法创建具体类型的泛型数组 反射其实可以绕过泛型的限制 什么是Java泛型 Java 泛型(ge

  • 一篇文章带你搞懂Java线程池实现原理

    目录 1. 为什么要使用线程池 2. 线程池的使用 3. 线程池核心参数 4. 线程池工作原理 5. 线程池源码剖析 5.1 线程池的属性 5.2 线程池状态 5.3 execute源码 5.4 worker源码 5.5 runWorker源码 1. 为什么要使用线程池 使用线程池通常由以下两个原因: 频繁创建销毁线程需要消耗系统资源,使用线程池可以复用线程. 使用线程池可以更容易管理线程,线程池可以动态管理线程个数.具有阻塞队列.定时周期执行任务.环境隔离等. 2. 线程池的使用 /** *

  • 一文带你深入了解Java中延时任务的实现

    目录 概述 JAVA DelayQueue DelayQueue的实现原理 DelayQueue实现延时队列的优缺点 时间轮算法 时间轮的具体实现 进阶优化版时间轮算法 时间轮算法的应用 小结 redis延时队列 mq延时队列 rocketmq延时消息 rocketmq的精准延时消息 总结 概述 延时任务相信大家都不陌生,在现实的业务中应用场景可以说是比比皆是.例如订单下单15分钟未支付直接取消,外卖超时自动赔付等等.这些情况下,我们该怎么设计我们的服务的实现呢? 笨一点的方法自然是定时任务去数

  • 一文带你全面了解Java Hashtable

    目录 概述 介绍和使用 核心机制 实现机制 扩容机制 源码解析 成员变量 构造函数 put方法 get方法 remove方法 总结 概述 HashTable是jdk 1.0中引入的产物,基本上现在很少使用了,但是会在面试中经常被问到,你都知道吗: HashTable底层的实现机制是什么? HashTable的扩容机制是什么? HashTable和HashMap的区别是什么? 介绍和使用 和HashMap一样,Hashtable也是一个散列表,它存储的内容是键值对(key-value)映射, 重要

  • 一文带你搞懂Java中的递归

    目录 概述 递归累加求和 计算1 ~ n的和 代码执行图解 递归求阶乘 递归打印多级目录 综合案例 文件搜索 文件过滤器优化 Lambda优化 概述 递归:指在当前方法内调用自己的这种现象. 递归的分类: 递归分为两种,直接递归和间接递归. 直接递归称为方法自身调用自己. 间接递归可以A方法调用B方法,B方法调用C方法,C方法调用A方法. 注意事项: 递归一定要有条件限定,保证递归能够停止下来,否则会发生栈内存溢出. 在递归中虽然有限定条件,但是递归次数不能太多.否则也会发生栈内存溢出. 构造方

  • 一文带你弄懂Java中线程池的原理

    目录 为什么要用线程池 线程池的原理 ThreadPoolExecutor提供的构造方法 ThreadPoolExecutor的策略 线程池主要的任务处理流程 ThreadPoolExecutor如何做到线程复用的 四种常见的线程池 newCachedThreadPool newFixedThreadPool newSingleThreadExecutor newScheduledThreadPool 小结 在工作中,我们经常使用线程池,但是你真的了解线程池的原理吗?同时,线程池工作原理和底层实

  • ECMAScript 6即将带给我们新的数组操作方法前瞻

    本文介绍ECMAScript 6即将带给我们新的数组操作方法,以及在怎样在现有浏览器应用这些新的数组特性. Note: 我将使用交替使用构造器(constructor)和类(class)两个术语. 类方法 数组(Array)自身所拥有的方法. Array.from(arrayLike, mapFunc?, thisArg?) Array.from()的基本功能是,转换两种类型的对象成数组. 类数组对象(Array-like objects) 该类对象有长度与索引的属性.DOM操作符的结果即属于该

  • Java数组的基本学习教程

    Java数组声明.创建.初始化 一维数组的声明方式: type var[]; 或type[] var; 声明数组时不能指定其长度(数组中元素的个数), Java中使用关键字new创建数组对象,格式为: 数组名 = new 数组元素的类型 [数组元素的个数] 实例: TestNew.java: 程序代码: public class TestNew { public static void main(String args[]) { int[] s ; int i ; s = new int[5]

  • Java数组模拟优先级队列数据结构的实例

    优先级队列 如果我们给每个元素都分配一个数字来标记其优先级,不妨设较小的数字具有较高的优先级,这样我们就可以在一个集合中访问优先级最高的元素并对其进行查找和删除操作了.这样,我们就引入了优先级队列 这种数据结构. 优先级队列(priority queue) 是0个或多个元素的集合,每个元素都有一个优先权,对优先级队列执行的操作有(1)查找(2)插入一个新元素 (3)删除 一般情况下,查找操作用来搜索优先权最大的元素,删除操作用来删除该元素 .对于优先权相同的元素,可按先进先出次序处理或按任意优先

随机推荐