Java开发必备知识之数组详解
一、ASCII码
二、为什么需要数组
案例： 160班 现在 77人 统计 全班的Java成绩 用程序进行存储 变量 统计 全班不及格的同学 要 补考 补考过的同学 修改成绩 定义 77 个变量 int 帅 = 59； int 洋 = 100； int cto = 60； int ceo = 58；
三、什么是数组
概念：数组就是内存中一块 连续的 内存空间，用于存放 相同类型 的多个数据
四、定义数组
声明一个数组：确定数组中存放的数据类型
语法：
数据类型[] 数组名；//建议
数据类型 []数组名；
数据类型 数组名[];//c语言的写法 不建议
案例：
//声明一个数组
int[] a ;
为数组开辟空间：确定了数组的容量大小
语法：数组名 = new 数据类型[数组的长度]；
案例：//为数组开辟空间
a = new int[77];
数组的长度：自动获取数组的长度 数组名.length
数组的下标:为每个数组的元素分配一个标号 0------数组名.length-1
数组的元素：数组中每个小空间叫做数组的一个元素相当于一个变量
定义数组的其他方式
第一种：声明 开辟空间（隐式）
1）先声明 后开辟空间
语法：
数据类型[] 数组名；//声明
数据名 = new 数据类型[数组长度];//开辟空间
2）声明的同时并开辟空间
语法：数据类型[] 数组名 = new 数据类型[数组长度]；
第二种：声明 赋值（显式初始化）
1）先声明 后赋值
语法：
数据类型[] 数组名 ；//声明
数组名 = new 数据类型[]{元素1，元素2，元素3，。。。}；//赋值
2)声明的同时并赋值
语法：数据类型[] 数组名 = new 数据类型[]｛元素1，元素2，元素3，。。。｝;
简写形式：数据类型[] 数组名 = ｛元素1，元素2，元素3，。。。｝；
注意：
1.简写形式不能分为两行 数组的声明和赋值必须在同一行
2.在定义数组的过程中 不能既赋值同时又定义长度
五、使用数组
存数据：为每个元素赋值
取数据：
语法：数组名[数组下标] = 值；
案例：
public class Demo{
public static void main(String[] args) {
//声明一个数组
int[] a ;
//为数组开辟空间
a = new int[4];
//存数据
a[0] = 2;
a[1] = 4;
a[2] = 6;
a[3] = 8;
//访问数据
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a[3]);
//获取数组的长度
System.out.println("数组的长度："+a.length);
}
}
六、数组的默认值
当定义一个数组没有为数组赋值数组的每一个元素都有一个默认值 默认值的类型和数组的类型是相关的
简单数据类型
byte--------------0
short-------------0
int -------------0
long--------------0
float ------------0.0
double------------0.0
char-------------空字符 '\u0000'
boolean----------false
引用数据类型（对象类型）------null
案例:
public class Demo{
public static void main(String[] args) {
//定义一个数组
String[] a = new String[5];
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a[3]);
System.out.println(a[4]);
}
}
七、数组的遍历
遍历：访问数组中的每个元素并打印
案例：
public class Demo{
public static void main(String[] args) {
int[] a = {3,5,6,7,8,3,23,56,78,52,34};
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+"\t");
}
}
}
八、数组在内存中的分析
int[] a = new int[4];
a的引用指向 数组在堆内存中的实体 （见图示）
元素的地址值 = 首地址+数据类型字节数*下标
案例：
public class Demo{
public static void main(String[] args) {
int[] a = new int[3];
a[0] = 2;
a[1] = 3;
a[2] = 5;
int[] b = new int[4];
b = a;
System.out.println("b数组的长度："+b.length);
System.out.println("a数组的长度："+a.length);
for(int i =0;i<b.length;i++){
System.out.print(b[i]+" ");
}
}
}
九、数组的扩容
思想：
1.定义一个新的数组 容量要比之前的数组大
2.将原数组中的元素 复制到新数组中
3.将原数组的引用指向新数组
注意：如果超出了数组的下标 那么会报异常
java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常
方法：
=========================================================================================
第一种：自己写
代码：
public class Demo{
public static void main(String[] args) {
int[] a = {2,4,6,3,7,5,23};//7
System.out.println("扩容之前的长度："+a.length);
//1,定义一个新数组
int[] b = new int[a.length*2];
//2,将原数组元素复制到新数组中
for(int i = 0;i<a.length;i++){
b[i] = a[i];
}
//3 将a的引用指向新数组
a = b;
//遍历a数组
System.out.println("扩容之后的长度："+a.length);
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
=================================================================
第二种：利用 System.arraycopy(原数组名,原数组的起始下标,新数组名,新数组的起始下标,要复制的长度)
代码：
public class Demo{
public static void main(String[] args) {
int[] a = {2,4,6,3,7,5,23};//7
System.out.println("扩容之前的长度："+a.length);
//1,定义一个新数组
int[] b = new int[a.length*2];
//2,将原数组元素复制到新数组中
System.arraycopy(a,0,b,0,a.length);
/*for(int i = 0;i<a.length;i++){
b[i] = a[i];
}
*/
//3 将a的引用指向新数组
a = b;
//遍历a数组
System.out.println("扩容之后的长度："+a.length);
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
==================================================================
第三种：利用Arrays工具类 操作
Arrays是java.util包中的一个工具类
Arrays.copyOf(原数组，扩容之后的长度) 此函数可以返回一个新的扩容之后的数组数组长度由函数的第二个参数决定
代码：
import java.util.*;
public class Demo{
public static void main(String[] args) {
int[] a = {2,4,6,3,7,5,23};//7
System.out.println("扩容之前的长度："+a.length);
a = Arrays.copyOf(a,a.length*2);
System.out.println("扩容之后的长度："+a.length);
//遍历
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
练习：随机点名系统
import java.util.*;
public class Demo{
public static void main(String[] args) {
String[] s = {"",""};
//系统随机产生一个下标
int index = (int)(Math.random()*s.length);
System.out.println(s[index]);
}
}
案例：随机赋值
import java.util.*;
public class Demo{
public static void main(String[] args) {
int[] a = new int[10];
//循环赋值
for(int i = 0;i<a.length;i++){
a[i] = (int)(Math.random()*100);
}
//遍历
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
十、数组用在函数的参数上
案例：写一个函数 函数的功能是遍历数组 形参类型 数组类型 参数几个 1 返回值 void printArray
代码：
import java.util.*;
public class Demo{
public static void main(String[] args) {
int[] a = {3,4,56,7,8,8,9,9,3,5,66,77,88};
printArray(a);
System.out.println();
int[] b = new int[10];
printArray(b);
}
//
public static void printArray(int[] a) {
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+",");
}
}
}
数组用在函数的参数和返回值上
案例：写一个函数 实现数组的扩容
代码：
import java.util.*;
public class Demo{
public static void main(String[] args) {
int[] a = {3,4,56,7,8,8,9,9,3,5,66,77,88};
//调用 扩容
a = myCopyOf(a);
printArray(a);
}
//
public static void printArray(int[] a) {
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+",");
}
}
//扩容数组
public static int[] myCopyOf(int[] a) {
//定义一个新数组
int[] b = new int[a.length*2];
//将原数组的元素复制到新数组
for(int i = 0;i<a.length;i++){
b[i] = a[i];
}
return b;
}
}
案例：定义一个函数 函数的功能是 计算多个数的和 数不定
代码：
import java.util.*;
public class Demo{
public static void main(String[] args) {
int[] a = {3,4,5};
int sum = add(a);
System.out.println(sum);
}
//定义一个函数 实现 计算几个数的和
public static int add(int[] a) {
int sum = 0;
for(int i = 0;i<a.length;i++){
sum+=a[i];
}
return sum;
}
}
十一、函数可变长参数
语法： 数据类型... 变量名
就相当于 数据类型[] 变量名；
public static 返回值类型 函数名（数据类型... 变量名）｛
｝
注意：可变长参数函数中的形参列表只能有一个可变长参数，如果有其他的形参，那么可变长参数必须放在参数列表的最后
案例：
import java.util.*;
public class Demo{
public static void main(String[] args) {
/*int sum1 = add(3,4,5);
int sum2 = add(4,6,9);
int sum3 = add(3,6,8,9,4,3);*/
int sum = add(3,4,6);
System.out.println(sum);
}
//定义一个可变长参数函数
public static int add(int b,int c,int...a) {
int sum = 0;
for(int i = 0;i<a.length;i++){
sum+=a[i];
}
return sum;
}
}
案例：传数组也可以
import java.util.*;
public class Demo{
public static void main(String[] args) {
int[] a = {1,2,3};
int sum = add(a);
System.out.println(sum);
}
//定义一个可变长参数函数
public static int add(int...a) {
int sum = 0;
for(int i = 0;i<a.length;i++){
sum+=a[i];
}
return sum;
}
}
案例：这样是不行的
import java.util.*;
public class Demo{
public static void main(String[] args) {
int sum = add(2,4,5);
System.out.println(sum);
}
//定义一个可变长参数函数
public static int add(int[] a) {
int sum = 0;
for(int i = 0;i<a.length;i++){
sum+=a[i];
}
return sum;
}
}
十二、数组的排序
1.4. 6.8.3 ---- 1 3 4 6 8 套路：算法
十三、冒泡排序
规则：相邻的两个元素进行比较 如果前者大于后者 则两者交换位置
案例： 3,1,4,2 ------->1 2 3 4
***
**
*
双重for循环
代码：
import java.util.*;
public class Demo{
public static void main(String[] args) {
int[] a = {3,5,87,34,67,2,95,36,67,78};
//int[] a = {3,1,4,2};
//冒泡排序
for(int i = 1;i<=a.length-1;i++){
for(int j = 0;j<a.length-i;j++){
if (a[j]>a[j+1]) {
//交换位置
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
//遍历
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
选择排序
规则：在数组中选择一个数 和其他的数进行比较 如果这个数大于其他的数 那么两者交换位置
代码：
import java.util.*;
public class Demo{
public static void main(String[] args) {
int[] a = {3,5,87,34,67,2,95,36,67,78};
//int[] a = {3,1,4,2};
//冒泡排序
/*for(int i = 1;i<=a.length-1;i++){
for(int j = 0;j<a.length-i;j++){
if (a[j]<a[j+1]) {
//交换位置
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}*/
//选择排序
for(int i = 0;i<=a.length-2;i++){
for(int j = i+1;j<a.length;j++){
if (a[i]>a[j]) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
//遍历
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
快速排序
jdk提供的属于java.util中的Arrays工具类的函数
java.util.Arrays.sort(a);
代码：
public class Demo{
public static void main(String[] args) {
int[] a = {3,5,87,34,67,2,95,36,67,78};
//int[] a = {3,1,4,2};
//快速排序
java.util.Arrays.sort(a);
//遍历
for(int i = 0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
十四、二维数组
概念：是一维数组的一维数组 数组： 8中基本数据类型 引用数据类型 数组是引用数据类型 数据类型[] -----数组类型
二维数组的定义
数组的声明：
语法：
数据类型[][] 数组名;
为数组分配空间
语法：
数组名 = new 数据类型[高维数组长度][低维数组长度]
案例：
public class Demo{
public static void main(String[] args) {
int[][] a = new int[4][3];
/*int[] b = new int[4];
b[0] = new int[3];
b[1] = new int[3];
b[2] = new int[3];
b[3] = new int[3];*/
a[0][0] = 1;
a[0][1] = 2;
a[1][2] = 5;
for(int i = 0;i<a.length;i++){
for(int j = 0;j<a[i].length;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
二维数组的遍历
方法：先遍历高维 再遍历低维
代码：
for(int i = 0;i<a.length;i++){
for(int j = 0;j<a[i].length;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
二维数组的定义的其他方式
第一种：声明 分配空间
1）先声明 后分配空间
int[][] a;
a = new int[4][5] //4行5列
2）声明并分配空间
int[][] a = new int[4][5];
第二种：声明 赋值
1）先声明 后赋值
int[][] a ;
a = new int[][]{{2,3,4},{4,5,6},{4,6,8},{3,5,7}}
2)先声明并赋值
int[][] a =new int[][]{{2,3,4},{4,5,6},{4,6,8},{3,5,7}}
简写：int[][] a = {{2,3,4},{4,5,6},{4,6,8},{3,5,7}};
注意：简写形式不能分为两行 声明和赋值必须在同一行
案例：
public class Demo{
public static void main(String[] args) {
//声明并赋值
int[][] a = new int[][]{{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
for(int i = 0;i<a.length;i++){
for(int j = 0;j<a[i].length;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
不规则的二维数组
数组中每个元素数组的长度是不同的
int[][] a = {{1,2,3,3},{4,5},{7,8,9,8,56},{10,11,12}};
遍历：
public class Demo{
public static void main(String[] args) {
//声明并赋值
int[][] a = {{1,2,3,3},{4,5},{7,8,9,8,56},{10,11,12}};
for(int i = 0;i<a.length;i++){
for(int j = 0;j<a[i].length;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
注意的问题：
1.当定义一个二维数组 可以先为高维数组进行分配空间，再一一为低维数组进行初始化
案例：
public class Demo{
public static void main(String[] args) {
//声明并赋值
int[][] a;
a = new int[3][];
a[0] = new int[3];
a[1] = new int[4];
a[2] = new int[5];
for(int i = 0;i<a.length;i++){
for(int j = 0;j<a[i].length;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
2.当定义一个二维数组，必须先为高维分配空间，因为低维数组是依赖于高维数组创建的
案例：
public class Demo{
public static void main(String[] args) {
//声明并赋值
int[][] a;
a = new int[][4];//错误的
for(int i = 0;i<a.length;i++){
for(int j = 0;j<a[i].length;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
十五、引用之间的传递
到此这篇关于Java开发必备知识之数组详解的文章就介绍到这了,更多相关Java数组内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
java数组元素的引用实例讲解
对于数组来说,我们想要对其中的一个元素进行引用,那就离不开new的使用.大家在学习new的时候,一般是以新建和初始化的身份出现的.如果是用在数组的引用上,那么会以运算符的方式出现.下面我们就来看看数组元素,在new运算符中引用的具体内容吧. 定义并用运算符new为之分配空间后,才可以引用数组中的每个元素,数组元素的引用方式为: (1)arrayName[index] index为数组元素下标,可以使整形常亮或整形表达式.如: a[3], b[i], c[6*i]; (2)数组元素的下标从0开始:
-
Java 自定义动态数组方式
Java自定义动态数组 1.静态数组向动态数组转变 (1)静态数组,数组空间固定长度 这个数组空间总长为4,如果此时新插入一个数据就会报数组空间不足 (2)静态数组如何转变成动态数组 第一步:创建一个空间是data数组两倍的newData数组(扩容): 第二步:把data数组中的元素全部赋值到newData数组: 2.数组扩容程序 // 数组扩容 private void resize(int newCapacity){ E[] newData = (E[]) new Object[newCap
-
Java 数组的两种初始化方式
一.数组 1.数组中存储元素的类型是统一的,每一个元素在内存中所占用的空间大小是相同的,知道数组的首元素的内存地址,要查找的元素只要知道下标,就可以快速的计算出偏移量,通过首元素内存地址加上偏移量,就可以快速计算出要查找元素的内存地址.通过内存地址快速定位该元素,所以数组查找元素的效率较高. 2.随机的对数组进行增删元素,当增加元素的时候,为了保证数组中元素在空间存储上是有序的,所以被添加元素位置后面的所有元素都要向后移动,删除元素也是,后面所有的元素要向前移动,所以数组的增删元素效率很低.
-
浅谈Java数据结构之稀疏数组知识总结
稀疏数组 当一个数组中的元素大多为0或者相同元素的时候,可以用稀疏数组来压缩 稀疏数组只记录 行row 列col 值value 将下列的二维数组转为稀疏数组,如下两图所示 1.实现二维数组转为稀疏数组的步骤: 遍历数组,得到数组中 不为0的个数,并记录为sum,作为稀疏数组第0行的 value 遍历数组,将数组中不为0的数的行和列和值分别写入稀疏数组的 row col val 中 代码实现: public class SparseArray { public static void main(S
-
Java基础之数组超详细知识总结
一.一维数组 1.Java语言中的数组是一种 引用数据类型.不属于基本数据类型.数组的父类是 Object. 2.数组实际上是一个容器,可以同时容纳多个元素.(数组是一个数据的集合) 3.数组当中可以存储"基本数据类型"的数据,也可以存储"引用数据类型"的数据. 4.数组因为是引用类型,所以数组对象存储在 堆内存 当中.(数组是存储在堆当中的) 5.数组当中如果存储的是"java对象"的话,实际上存储的是对象的"引用(内存地址)&quo
-
java二维数组指定不同长度实例方法
我们知道二维数组,是在一维数组的基础上进行了维度的增加.那么在实际使用的过程中,有时候我们所需要的二维数组,它们其中的维度是不同的,这就需要我们手动的进行设置.下面我们就来一起探究,二维数组在改变维度长度大小的方法,并辅以实例进行代码展示. 1.二维数组的每个元素都是一个一维数组,这些数组不一定都是等长的.声明二维数组的时候可以只指定第一维大小,空缺出第二维大小,之后再指定不同长度的数组.但是注意,第一维大小不能空缺(不能只指定列数不指定行数). public class ArrayTest4
-
教你怎么用Java数组和链表实现栈
一.何为栈? 栈(stack)又名堆栈,它是一种运算受限的线性表.限定仅在表尾进行插入和删除操作的线性表.这一端被称为栈顶,相对地,把另一端称为栈底.向一个栈插入新元素又称作进栈.入栈或压栈,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素:从一个栈删除元素又称作出栈或退栈,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素. 栈可以类比成现实生活中的弹夹或者羽毛球桶 二.用数组实现栈 用数组模拟栈的思路分析如图: 1.定义一个top变量(指针)表示栈顶初始化为-1. 2.定义一个变量来记
-
解决java main函数中的args数组传值问题
这几天面试中有遇到关于main数组中的args数组传值的问题,一般是从命令提示符中传值,也可以直接在java代码中赋值. 而且这个数组的长度是动态的,根据传值的个数确定数组的长度. 1.从命令提示符中传值 我在桌面新建了一个文本文档重命名为TestMain.java,代码如下 public class TestMain { public static void main(String[] args) { System.out.println("hello "+args[0]); Sys
-
java中用数组实现环形队列的示例代码
本篇文章主要讲述了使用数组实现环形队列的思路以及具体代码 一.队列是什么 我们先来看下百科的解释: 队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,队列是一种操作受限制的线性表.进行插入操作的端称为队尾,进行删除操作的端称为队头. 总结起来两点: 1.一种线性表 2.添加操作只能在表尾,删除操作在表头(先进先出) 二.实现队列的思路 1.初始化一个空队列 初始化一个大小固定的数组,并将头指针,尾指针都指向下表为0的位置,但其
-
Java算法之数组冒泡排序代码实例讲解
冒泡排序是数组查找算法中最为简单的算法 冒泡排序原理: 假设一个数组长度为k(最高索引k-1),遍历前k - 1个(最高索引k-2)元素,若数组中的元素a[i]都与相邻的下一个元素a[i+1]进行比较,若a[i] > a[i+1] ,则这两个元素交换位置.以此类推,若a[i+1] > a[i+2],则交换位置-直至a[k-2]与a[k-1]比较完毕后,第0轮迭代结束.此时,a[k-1]为数组元素中的最大值. 第1轮迭代,再对数组a的前k-1个元素重复进行以上操作. - 第k-2轮迭代,对数组a