学习笔记十三：Java之数组

最新推荐文章于 2025-03-18 15:35:12 发布
原创 最新推荐文章于 2025-03-18 15:35:12 发布 · 360 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
Java

当前文章被收录于：

Java
57 篇文章 0 人学习
订阅专栏 查看详情
本文深入探讨了Java中数组的声明与初始化方法，并详细介绍了四种排序算法：快速排序、冒泡排序、选择排序和插入排序。同时展示了如何使用Java内置的Arrays类进行数组排序、复制、填充和二分查找等操作。

只有创造，才是真正的享受，只有拚搏，才是充实的生活。


本讲内容：数组

数组是Java中的对象，它用来存储多个相同类型的基本数据类型或者对象引用。


一、声明数组
数组是通过说明它将要保存的元素类型来声明的，元素类型可以是对象或者基本类型。类型后面的方括号可以在写在标识符的前面，也可以写在后面。推荐写在前面。int[ ] a      int a[ ]


二、 一维数组

1、int[] a;   //声明,没有初始化

2、int[] a=new int[5];   //声明并初始化为默认值,int型为0

3、 int[] a={1,2,3,4,5};   //声明并初始化为给定值

4、 int[] a;   a=new int[5];  //正确，声明与初始化分开

5、int[] a; a={1,2,3,4,5};   //错误,数组常量只能在初始化操作中使用，如3

6、 int a[];a[0]=1; a[1]=2;   //错误,因为数组没有初始化,不能赋值


三、二维数组

1、 int[][] a;  //声明,没有初始化

2、 int[][] a=new int[2][3];    //声明并初始化为默认值,int型为0

3、 int[][] a={{1,2},{2,3},{3,4}};   //声明并初始化为给定值 
     int[][] a={{1,2},{2,3},{3,4,5}};   //没有错,数组空间不是连续分配的，所以不要求每一维的大小相同

4、 int[][] a=new int[2][];
     a[0]=new int[3];  //a[0]其实就是一个数组
     a[1]=new int[4];  //每一维的大小可以不一样;

5、int[][] a=new int[][]{{1,2},{2,3},{3,4,5}};   //同(3)  

     int[] a=new int[5]{{1,2},{2,3},{3,4,5}};  //错误,如果提供了数组初始化操作，则不能定义维表达式

     int[][] a=new int[2][];
     a[0]={1,2,3,4,5};   //错误,数组常量只能在初始化操作中使用

6、int[][] a=new int[2][];
     a[0][1]=1;   //错误,第二维没有初始化,不能赋值,java.lang.NullPointerException异常

总结: 1.二维就是数组的数组,里面的数组大小不要求一样
        2.不管一维还是二维,在使用前(赋值,访问)必须初始化,可以用new默认初始化,也可以用数组常量初始化


四、初始化分类

1.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。int[] a=new int[2]


下面我们通过例子讲解

1、一维数组：

<span style="font-size:18px;"><span style="font-size:18px;">public class T19 {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int arr[]=new int[5];
		int sum=0;
		for(int i=0;i<5;i++){
			System.out.println("请输入第"+(i+1)+"学生成绩");
			arr[i]=in.nextInt();
			sum+=arr[i];
		}
		System.out.println("这5个人的平均分为"+sum/5);
	}
}</span></span>

2、规则二维数组： 

<span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[][] a={{1,2},{3,4},{5,6}};
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				System.out.println(a[i][j]);
			}
		}
	}
}</span>
打印：1 2 3 4 5 6

3、不规则二维数组：

<span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[][] a={{1,2},{3,4,5},{6,7,8,9}};
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				System.out.println(a[i][j]);
			}
		}
	}
}</span>
打印：1 2 3 4 5 6 7 8 9

 

4、打印图形

<span style="font-size:18px;">public class T {
	public static void main(String[] args) {
		int[][] arr=new int[4][6];
		
		arr[1][2]=1;
		arr[2][1]=2;
		arr[2][3]=3;
		
		//先访问行再访问列
		for(int i=0;i<4;i++){//行
			for(int j=0;j<6;j++){//列
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
	}
}</span>

<span style="font-size:18px;">0 0 0 0 0 0 
0 0 1 0 0 0 
0 2 0 3 0 0 
0 0 0 0 0 0 </span>

五、数组排序

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。
1、快速排序法
<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a={7,3,6,9,4};
		Arrays.sort(a);
		for(int i :a){//<span style="color: rgb(51, 51, 51); font-family: Helvetica, Tahoma, Arial, sans-serif; font-size: 14px; line-height: 24px; background-color: rgb(245, 245, 245);">遍历整个集合</span>
			System.out.println(i);
		}
	}
}</span></span>

2、冒泡法  比较相邻的俩个数，把小的数放在前面

冒泡排序是稳定性排序方法。比较适合参加排序序列的数据量较小的情况，这种方法是排序时间效率最低的一种。

总共进行 1 + 2 + 3 + 4 + . . . + n-1 = n(n-1) /2次
<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a={7,3,6,9,4};
		bubbleSort(a);
		for(int i :a){
			System.out.println(i);
		}
	}
	public static int[] bubbleSort(int[] a){
		for(int i=0;i<a.length-1;i++){//a.length=5  走几次，一次确定一个数，一共有a.length-1次
			for(int j=i+1;j<a.length;j++){
				if(a[i]>a[j]){
					int temp;
					temp=a[j];
					a[j]=a[i];
					a[i]=temp;
				}
			}
		}
		return a;
	}
}</span></span>

3、选择排序算法（选择最小的一个数与第一个数交换）

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a={7,3,6,9,4};
		selectSort(a);
		for(int i :a){
			System.out.println(i);
		}
	}
	public static int[] selectSort(int[] a){
		for(int i=0;i<a.length-1;i++){
			int min=i;
			for(int j=i+1;j<a.length;j++){
				if(a[min]>a[j]){
					min=j;
				}
			}
			if(min!=i){
				int temp=a[i];
				a[i]=a[min];
				a[min]=temp;
			}
		}
		return a;
	}
}</span></span>


<span style="font-size:18px;"><span style="font-size:18px;">import java.util.*;

public class T {
	public static void main(String[] args) {
		//打印系统时间
		Calendar cal=Calendar.getInstance();
		System.out.println("排序前时间："+cal.getTime());
		//Math.random()让程序随机产生一个0～1
		int t=(int)(Math.random()*100);
		System.out.println(t);
		System.out.println("排序后时间："+cal.getTime());
	}
}</span></span>
<span style="font-size:18px;"><span style="font-size:18px;">排序前时间：Sat Dec 27 21:42:20 CST 2014
58
排序后时间：Sat Dec 27 21:42:20 CST 2014
</span></span>

4、插入排序法（比选择排序快）

把n个等排序的元素看成一个有序列表和一个无序列表，开始时有序列表只有一个元素，无序列表有n-1个元素，排序过程中每次从无序列表中拿出一个数与有序列表比较，将它插入有序列表中使之成为新的有序列表。

<span style="font-size:18px;"><span style="font-size:18px;">public class T {
	public static void main(String[] args) {
		int len=8;
		int[] arr=new int[len];
		for(int i=0;i<len;i++){
			int t=(int)(Math.random()*100);
			arr[i]=t;
		}
		
		InsertSort is=new InsertSort();
		is.sort(arr);
		
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
	}
}

class InsertSort{
	public void sort(int arr[]) {
		for(int i=1;i<arr.length;i++){
			int insertVal=arr[i];
			int index=i-1;
			while(index>=0&&insertVal<arr[index]){
				arr[index+1]=arr[index];
				index--;
			}
			arr[index+1]=insertVal;
		}
	}
}
</span></span>

5、快速排序法（比上面的快百倍）

以中间一直二分开比较

<span style="font-size:18px;">public class T {
	public static void main(String[] args) {
		int len=8;
		int[] arr=new int[len];
		for(int i=0;i<len;i++){
			int t=(int)(Math.random()*100);
			arr[i]=t;
		}
		
		QuickSort is=new QuickSort();
		is.sort(0,arr.length-1,arr);
		
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
	}
}

class QuickSort{
	public void sort(int left,int right,int[] arr) {
		int l=left;
		int r=right;
		int pivot=arr[(left+right)/2];
		int temp=0;
		while(l<r){
			while(arr[l]<pivot) l++;
			while(arr[r]>pivot) r--;
			if(l>=r) break;
			
			temp=arr[l];
			arr[l]=arr[r];
			arr[r]=temp;
			
			if(arr[l]==pivot) --r;
			if(arr[r]==pivot) ++l;
		}
		if(l==r){
			l++;
			r--;
		}
		if(left<r) sort(left,r,arr);
		if(right>l) sort(l,right,arr);
	}
}
</span>


六、数组Arraysr的重要方法

Arrays.sort()


排序

clone()

复制数组：限制：全部复制，无法部分的复制。


Arrays.fill（ a1, value ）
a1是一个数组变量，value是一个a1中元素数据类型的值，作用：填充a1数组中的每个元素都是value
Arrays.fill(a, fromIndex, toIndex, val)
第一个参数指操作的数组，第二个和第三个指在该数组的某个区域插入第四个参数，第二个参数指起始元素下标（包含该下标），第三个参数指结束下标（不包含该下标）

Arrays.binarySearch()


找出某个数的下标值，缺点：数组必须已经过了排序，否则结果无法预料 
Arrays.toString()

显示数组数据





例如： 

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a=new int[5];
		Arrays.fill(a,3);
		for(int i :a){
			System.out.println(i);
		}
	}
}</span></span>
打印：3 3 3 3 3


<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a=new int[5];
		Arrays.fill(a,3);
		Arrays.fill(a, 1,3,1);
		for(int i :a){
			System.out.println(i);
		}
	}
}	</span></span>

打印：3 1 1 3 3


<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a=new int[5];
		int[] b;
		Arrays.fill(a, 2);
		b=a.clone();
		for(int i :b){
			System.out.println(i);
		}
	}
}</span></span>

打印：2 2 2 2 2


<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a = { 1, 2, 4, 5, 3 };
		Arrays.sort(a);
		System.out.println(Arrays.binarySearch(a, 5));
	}
}</span></span>

<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-family: Arial;font-size:18px; line-height: 26px;">打印：4</span></span></span>


<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a = { 1, 5, 6, 7, 3, 1 };
		System.out.println(Arrays.toString(a));
	}
}</span></span>
<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-family: Arial;font-size:18px; line-height: 26px; white-space: pre;">打印：</span>[1, 5, 6, 7, 3, 1]</span></span>


七、二分法查找

<span style="font-size:18px;">public class T {
	public static void main(String[] args) {
		int[] arr={2,3,6,89,4};
		BinaryFind bf=new BinaryFind();
		bf.find(0,arr.length-1,3,arr);
	}
}

class BinaryFind{
	public void find(int leftIndex,int rightIndex,int val,int[] arr) {
		//首先找到中间的数
		int midIndex=(rightIndex+leftIndex)/2;
		int midVal=arr[midIndex];
		
		if(rightIndex>=leftIndex){
	
		if(midVal>val){
			//在arr左边数中找
			find(leftIndex,midIndex-1,val,arr);
		}else if(midVal<val){
			find(midIndex+1,rightIndex,val,arr);
		}else if(midVal==val){
			System.out.println("找到下标"+midIndex);
			}
		}
	}
}</span>

<span style="font-size:18px;">找到下标1</span>


本讲就到这里，Take your time and enjoy it

java周测题（1）
qq_45111873的博客
07-19 675
一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3 编程找出1000以内的所有完数。 public class Demo1 { public static void main(String[] args) { //求1000以内的所有完数 int sum=0; //统计完数个数 for(int i=1;i<=1000;i++) { int x=0; .
java学习笔记——数组和二维数组
最新发布
qq_24992377的博客
06-05 777
​​。
public static void main(String[] args) 隐含了什么？
williamamg的博客
03-20 7030
public class TestSort { public static void main(String[] args) { // 需要分别用Javac和Java命令行编译和运行 int[] arr; int temp = 0; arr = new int [9]; for (int i = 0; i < arr.length; i++){ arr[i] = In
Java创建数组arr1和arr2,将数组arr1中的索引0-3中的元素复制到arr2中。
程序研博客
08-24 2078
package javase6; import java.util.Arrays; public class Javase6_1 { public static void main(String[]args){ int arr1[]=new int[]{1,2,3,4,5,6,7,8,9,10}; int arr2[]= Arrays.copyOfRange(arr1,0,3); //索引0-3中的元素进行复制 for (int i=1.
Java中对Arr数组的常用操作
qq_42461843的博客
06-15 6232
此内容转载，非原创。附：转载地址点击打开链接 点击打开链接 点击打开链接 点击打开链接 点击打开链接 点击打开链接目录：声明数组；初始化数组；查看数组长度；遍历数组；int数组转成string数组；从array中创建arraylist；数组中是否包含某一个值；将数组转成set集合；将数组转成list集合；Arrays.fill()填充数组；数组排序；复制数组；比较两个数组；去重复；查询数组中的最大...
Java学习笔记（十三）——数组
weixin_44592380的博客
03-20 242
文章目录一、数组的概念1、数组的定义2、创建数组对象3、初始化二、数组的常见操作1.数组的遍历2、数组的拷贝3、java.util.Arrays类三、多维数组四、数组存储表格数据1、使用二维数组保存表格数据2、使用javabean和一维数组保存表格数据五、Comparable接口 一、数组的概念 1、数组的定义 数组是相同类型数据的有序集合。其中每一个数据称为元素，每个元素可通过一个索引【下标】来访问他们。数组的四个基本特点： 长度是确定的。数组一旦被确定，它的大小就是不可改变的。 其元素类型必须是相
Java 学习笔记 - 数组类型互转
灵台方寸山斜月三星洞
01-10 2万+
测试数据 字符串数组 to （Integer、Long、Double）列表 传统方式 1.【String数组】转成【Long数组】 2.【Long数组】 转 【ArrayList】 Java8 Stream方式 数组 to 数组 字符串数组 to （int、long、double ）数组 int[]、long[]、double[] 数组互相转换 int[]、long[]、double[] 数组再转回 String[] 基础类型数组 to 列表 int数组 to 列表 long数组 to 列表 d
Java学习笔记
stange1的博客
05-06 5824
1.2.1 首先找到此电脑，右键点击属性，可以按照下面的界面；点击【高级系统设置】，再点击【环境变量】 1.2.2 找到JDK的bin目录，复制一下 1.2.3 将JDK的bin目录粘贴在Path环境变量后面 1.2.4.在CMD输入javac -version 看提示信息是否显示你安装JDK的版本号​ 1、java 基础（Java SE）标准版 2、就业方向：①JavaEE软件工程师②大数据③android开发 3、运行原理示意图 4、Java 开发注意事项和细节说明 5、如何快速掌握技术或知识点 代
Java菜鸟学习笔记--数组篇(三):二维数组
热门推荐
Gian.Yang
08-07 6万+
定义 //1.二维数组的定义 //2.二维数组的内存空间 //3.不规则数组 package me.array; public class Array2Demo{ public static void main(String[] args){ //定义二维数组 int[ ] [ ] arr={{1,2,3},{4,5,6}}; //静态初始化
Java基础（十三）：Java中的数组使用
康宝的博客
02-08 866
java的数组使用
java学习笔记：数组
weixin_43854404的博客
01-20 1043
java学习笔记：数组1.数组(Array)2.数组的常见概念3.数组的特点：4.数组的分类5. 一维数组的使用① 一维数组的声明和初始化1>静态初始化:数组的初始化和数组元素的赋值同时进行**2>动态初始化：数组的初始化数组元素的赋值分开进行② 如何调用数组的指定位置的元素③ 如何获取数组的长度④ 如何遍历数组⑤ 数组元素的默认初始化值⑥ 数组的内存解析 ：见B站 尚硅谷143、144集6.二维数组的使用① 二维数组的声明和初始化1>静态初始化2>动态初始化② 如何调用数组的指
java学习笔记4——数组
qq_58956810的博客
03-18 1207
定义了一个基准值pivot，有两个指针，一个从数组的从前往后指，另外一个从后往前指，从前往后走，找到的第一个low比pivot大的，就停下来，high从后往前走，找到第一个比pivot小的就停下来，交换low与high，按照当前的索引，继续执行上述操作。定义数组:int[] arr2 = new int[]{2,4,5,8,12,15,19,26,37,49,51,66,89,100};定义数组:int[] arr =new int[]{34,54,3,2,65,7,34,5,76,34,67};
JAVA学习笔记：目录
任性的生鱼片 的博客
12-28 2323
目录 java学习笔记1：了解java、JDK、JRE、JVM java学习笔记2：JDK下载和安装以及测试控制台测试是否配置成功 java学习笔记3：用记事本写第一个java程序，第一个java程序常见错误总结，第一个java程序详细解析 java学习笔记4：常见的DOS命令和java开发工具 java学习笔记5：eclipse的下载及使用，以及java程序的运行 java学习笔记6：注释、标识...
Java学习笔记-数组
cj5785
04-02 2314
数组作为一种成熟的数据结构，在Java中也有着大量的运用 数组的定义 概念 同一种类型数据的集合。其实数组就是一个容器 数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素 数组也是一种类型，所有元素具有相同的类型 数组一旦完成初始化其长度就固定了 格式 格式1： 元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 示例：int[] arr = new int[5]; ...
Java学习笔记：数组
眼泪划过的星空
05-15 878
数组： 1，Java语言中的数组是一种引用类型，不属于基本数据类型，数组的父类是Object。 2，数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合。） 数组：字面意思是“一组数据”； 3，数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。 4，数组因为是引用类型，所以数组对象是堆内存当中。 5，数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）” 6，数组一旦创建，在Java中规定，长度不可变。 7，数组分类：一维数组，二维数组。。。 8，
Java学习笔记系列-基础篇-数组
嗨
04-25 485
Java学习笔记 Java学习笔记是一个持续更新的系列，工作多年，抽个空对自身知识做一个梳理和总结归纳，温故而知新，同时也希望能帮助到更多正在学习Java 的同学们。 本系列目录 入门篇 计算机基础 计算机编程语言 面向对象的编程思想 基础篇 环境搭建 第一个Java程序 开发工具 Java中的注释 标识符与关键字 变量与常量 数据类型 数组 数组 数组是储存数据类型相同的变量的集合，属于引用数据类型，自身也是堆中的一个对象。 声明方式 在Java中声明数组有两种方式，一是先声明数组长度，后赋值（
JavaSE基础知识(十三)--Java的数组以及数组的初始化
ruidianbaihuo的博客
06-09 1303
Java SE 是什么，包括哪些内容(十三)？ 本文内容参考自Java8标准 数组是相同类型的，用一个标识符名称封装到一起的一个对象引用序列或基本数据类型序列，数组是通过方括号下标操作符[ ]来定义和使用的，要定义一个数组，只需要在类型后面加上一个[ ]，并取一个合适的标识符名称即可。 上面的内容总共体现在三个方面： ⑴、数组内的数据类型必须是同一类型，也就是说在一个数组内不能同时存储不同数据类型...
JAVA学习笔记
lizzzza的博客
01-18 1596
JAVA学习笔记
Java学习笔记-Day07 Java数组
qq_42141141的博客
10-13 477
Java学习笔记-Day07 数组1、数组的介绍1.1、数组的概念1.2、数组的元素1.3、数组的长度1.4、数组的数据类型1.5、数组的区分1.6、数组的特点2、一维数组的声明3、一维数组的初始化4、一维数组的遍历     1、数组的介绍   1.1、数组的概念 数组是一组类型相同的数据的集合。 数组中可以存储多个数据，但是这些数据的类型必须相同。 数组能够作为数据的容器使用，把多个数据集中存储。 当需要同时保存多个类型相同的变量并进行处理时，可以考虑用数组。   1.2、数组的元素 数组中存储的数
Java学习笔记——数组
IT小小白的博客
04-04 465
Java学习笔记——数组 Day07 一、数组概述 1.数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成 其中，每一个数据称作一个元素称作数组元素可以通过一个下标来访问他们 二、数组声明创建 1.数组的声明和创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法： dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值