Java的第五章：数组

MY.MY.

已于 2023-06-01 18:57:31 修改

阅读量631

点赞数 2

文章标签： java eclipse

于 2023-03-17 22:11:19 首次发布

本文链接：https://blog.csdn.net/nmy15570188135/article/details/129528301

版权

数组概述

数组是具有相同数据类型的一组数据的集合。数组中的每个元素具有相同的数据类型。在Java中同样将数组看作一个对象，虽然基本数据类型不是对象，但由基本数据类型组成的数组却是对象。在程序设计中引入数组可以更有效地管理和处理数据。

一维数组

一维数组实质上是一组相同类型数据地线性集合，当在程序中需要处理一组数据，或者传递一组数据时，可以应用这种数组。

创建一维数组

数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。

1、先声明，再用new关键字进行内存分配

声明一维数组两种方式：

数组元素类型数组名字[];

数组元素类型[] 数组名字；

2、为数组分配内存同时设置初始值

数组元素的类型数组名=new数组元素类型[数组元素的个数]{值1，值2...};

使用一维数组

使用一维数组输出1~12月每个月份的天数，代码如下：

public class Hello{//创建类
	public static void main(String[] args) {//主方法
		int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
		for(int i=0;i<12;i++)//利用for循环将信息输出
			System.out.println((i+1)+"月有"+day[i]+"天");//输出每月的天数
	}
}

运行结果：

使用一维数组容易遇到数组越界问题

使用foreach语句遍历整数数组，代码如下：

public class Hello{
	public static void main(String[] args) {
		int[] arr=new int[] {5,13,96};//创建并初始化一维数组
		for(int temp:arr) {//temp的类型与arr元素的类型相同，for循环依次取出arr中的值并赋给temp
			System.out.println(temp);//输出
		}
	}
	}

运行结果：

二维数组

创建二维数组

1、先声明，再用new关键字进行内存分配

数组元素的类型数组名字[行数][列数];

数组元素的类型[行数][列数数组名字；

2、为数组分配内存同时设置初始值

数组名=new 数组元素的类型[][]{{值1，值2...},{值1，值2...}}

使用二维数组

输出一个3行4列且所有元素都为0的矩阵，代码如下：

public class Hello{//创建类
	public static void main(String[] args) {//主方法
		int a[][]=new int[3][4];//定义二维数组
		for(int i=0;i<a.length;i++) {
			for(int j=0;j<a[i].length;j++) {//for循环遍历数组中的每个元素
			System.out.print(a[i][j]);//将数组中的元素输出
		}
		System.out.println();//输出空格
	}
}
}

运行结果：

数组的基本操作

遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。

使用foreach语句遍历二维数组，代码如下：

public class Hello{//创建类
	public static void main(String[] args) {//主方法
		int arr2[][]={{4,3},{1,2}};//定义二维数组
		System.out.println("数组中的元素：");//提示信息
		int i=0;//外层循环计数器变量
		for(int x[]:arr2) {//外层循环变量为一维数组
			i++;//外层计数器递增
			int j=0;//内层循环计数器变量
			for(int e:x) {//循环遍历每一个数组元素
				j++;//内层计数器递增
				if(i==arr2.length&&j==x.length) {//判断变量是二维数组中的最后一个元素
					System.out.print(e);//输出二维数组的最后一个元素
				}else//如果不是二维数组中的最后一个数组
					System.out.print(e+"、");//输出信息
				}
			}
		}
	}

运行结果：

填充替换数组元素

数组中的元素定义完成后。可通过Arrays类的静态方法fill（）来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。

替换数组部分元素：前改后不改

使用fill（）方法填充数组元素，代码如下：

import java.util.Arrays;//导入java.util.Arrays类
public class part{//创建类
	public static void main(String[] args) {//主方法
		int arr[]=new int[5];//创建int型数组
		Arrays.fill(arr,8);//使用同一个值对数组进行填充
		for(int i=0;i<arr.length;i++) {//循环便利数组中的元素
			System.out.println("第"+i+"个元素是："+arr[i]);//将数组中的元素依次输出
		}
	}
		}

运行结果：

使用fill（）方法替换数组中的元素，代码如下：

import java.util.Arrays;//导入java.util.Arrays类
public class part{//创建类
	public static void main(String[] args) {//主方法
		int arr[]=new int[] {45,12,2,10};//定义并初始化int型数组arr
		Arrays.fill(arr,1,2,8);//使用fill（）方法替换数组指定范围内的元素
		for(int i=0;i<arr.length;i++) {//循环遍历数组中的元素
			System.out.println("第"+i+"个元素是："+arr[i]);//将数组中的每个元素输出
		}
	}
}

运行结果：

对数组进行排序

通过Arrays类的静态方法sort（）可以实现对数的排序。sort（）方法提供了多种重载形式，可以对任意类型的数组进行升序排序。

使用sort（）方法将数组排序后输出，代码如下：

import java.util.Arrays;//导入java.util.Arrays类
public class part{//创建类
    public static void main(String[] args) {//主方法
		int arr[]=new int[] {23,42,12,8};//声明数组
		Arrays.sort(arr);//将数组进行排序
		for(int i=0;i<arr.length;i++){//循环遍历排序后的数组
			System.out.println(arr[i]);//将排序后数组中的各个元素输出
	}
    }
	}

运行结果：

四、复制数组

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

复制数组元素：空位补0，溢出去掉

复制数组部分元素：前在后不在

1、copyOf()方法

复制数组，实现将此数组复制得到一个长度为5的新数组，并将新数组输出，代码如下：

import java.util.Arrays;//导入java.util.Arrays类
public class part{//创建类
	public static void main(String[] args) {//主方法
		int arr[]=new int[] {23,42,12};//定义数组
		int newarr[]=Arrays.copyOf(arr,5);//复制数组arr
		for(int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
			System.out.println(newarr[i]);//将新数组输出
		}
	}
}

运行结果：

2、copyOfRange()方法

按照索引复制数组，并将数组中索引位置是0~3的元素复制到新数组中，最后将新数组输出，代码如下：

import java.util.Arrays;//导入java.util.Arrays类
public class part{//创建类
	public static void main(String[] args) {//主方法
		int arr[]=new int[] {23,42,12,84,10};//定义数组
		int newarr[]=Arrays.copyOfRange(arr,0,3);//复制数组
		for(int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
			System.out.println(newarr[i]);//将新数组中的每个元素输出
		}
	}
}

运行结果：

查询数组

Arrays类的binarySearch()方法，可使用二分法搜索指定数组，以获得指定对象。该方法返回要搜索要搜索的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。

查询数组元素：先排序在查询，前含后不含

查找元素在数组中的索引位置，代码如下：

import java.util.Arrays;
public class part{
	public static void main(String[] args) {
		int ia[]=new int[] {1,8,9,4,5};//定义int型数组ia
		Arrays.sort(ia);//将数组进行排序
		int index=Arrays.binarySearch(ia,4);//查找数组ia中元素4的索引位置
		System.out.println("4的索引位置是："+index);//将索引输出
	}
}

运行结果：

在指定范围内查找元素在数组中的索引位置，代码如下：

import java.util.Arrays;
public class part{
	public static void main(String[] args) {
		String str[]=new String[] {"ab","cd","ef","yz"};//定义String型数组str
		Arrays.sort(str);//将数组进行排序
		int index=Arrays.binarySearch(str,0,2,"cd");//在指定范围内搜索元素“cd”的索引位置
		System.out.println("cd的索引位置是："+index);//将索引输出
	}
}

运行结果：

数组排序算法

冒泡排序

冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。

对一个int型的一维数组中的元素进行冒泡排序，代码如下：

public class part{
	 public static void main(String[] args) {
		 int[] array= {63,4,24,1,3,15};//创建一个数组，元素是乱序的
		 part sorter=new part();//创建冒泡排序类的对象
		 sorter.sort(array);//调用排序方法，对数组排序
	 }
	 public void sort(int[] array) {
		 for(int i=1;i<array.length;i++) {
			 for(int j=0;j<array.length-i;j++) {
				 if(array[j]>array[j+1]) {
					 int temp=array[j];//把第一个元素值保存到临时变量中
					 array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中
					 array[j+1]=temp;//把临时变量（第一个元素原值）保存到第二个元素单元中
				 }
			 } 
			 }
		 showArray(array);//输出冒泡排序后的数组元素
	 }
	 public void showArray(int[] array) {
		 for(int i:array) {//遍历数组
			 System.out.print(">"+i);//输出每个数组元素值
		 }
		 System.out.println();
	 }
	 }

运行结果：

直接选择排序

直接选择排序的基本思想是将指定排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值。

注意这里与冒泡排序的区别，不是交换相邻元素，而是把满足条件的元素与指定的排序位置元素交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，直至整个数组都变成已排序好的格式。

对一个int型的一维数组中的元素进行直接选择排序，代码如下：

public class part{
	public static void main(String[] args) {
		int[] array= {63,4,24,1,3,15};//创建一个数组，元素是乱序的
		part sorter=new part();//创建直接排序类的对象
		sorter.sort(array);//调用排序对象方法，对数组排序
	}
	public void sort(int[] array) {
		int index;
		for(int i=1;i<=array.length;i++) {
			index=0;
		for(int j=1;j<=array.length-i;j++) {
			if(array[j]>array[index]) {
				index=j;
			}
		}//交换在位置array.length-i和inde(最大值）上的两个数
			int temp=array[array.length-i];//把第一个元素值保存到临时变量中
			array[array.length-i]=array[index];//把第二个元素值保存到第一个元素单元中
			array[index]=temp;//把临时变量（第一个元素原值）保存到第二个元素单元中
	}
		showArray(array);//输出直接选择排序后的数组元素
}
	public void showArray(int[] array) {
		for(int i:array) {//遍历数组
			System.out.print(">"+i);//输出每个数组元素值
		}
		System.out.println();
	}
}

运行结果：

反转排序

把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以从类推，直接把所有数组元素反转替换。

MY.MY.

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java的第五章：数组

数组是具有相同数据类型的一组数据的集合。数组中的每个元素具有相同的数据类型。在Java中同样将数组看作一个对象，虽然基本数据类型不是对象，但由基本数据类型组成的数组却是对象。在程序设计中引入数组可以更有效地管理和处理数据。
复制链接

扫一扫