java中数组的定义及其基础应用

一维数组的定义及使用：

基础知识：

(1).定义：用来存储同一种数据类型，是定长的容器；数组的数据类型属于应用数据类型。

(2).使用数组的好处：一是可以存储多个同类型的数据，二是可以给这些数据从0开始编号，以便于操作这些数。

(3).语法格式

a.动态初始化格式：数组元素类型 [ ] 数组名 = new 数组元素类型 [ 元素个数] ;

还可以这样写：数组元素类型数组名 [ ] = new 数组元素类型 [元素个数];

举例：int [ ] arr = new int [ 5]; 或者 int arr [ ] = new int [ 5]; 即定义了一个长度为5的一维数组。

b.静态初始化格式：数组元素类型 [ ] 数组名 = new 数组元素类型 [ ] {元素1,元素2,元素3,......元素n};

或者：数组元素类型 [ ] 数组名 = {元素1,元素2,元素3,......元素n};

举例： String [ ] ass=new int [ ] {"Hello","frend","great","life"};

或者：String [ ] ass={"Hello","frend","great","life"};

两种初始化格式的选用注意：当确定了元素长度但不确定内容/类型则用动态初始化；

确定了元素类型而不确定长度则使用静态初始化。

(4).内存分析

java程序在运行时,需要在内存中分配空间,为了提高运算效率,又对空间进行了不同区域的划分,
因为每一篇区域都有特定的处理数据方式和内存管理方式

栈内存：用于存储局部变量 (方法里的变量,形式参数列表,定义在for循环中的等等) 当数据使用完

自动释放内存。

堆内存：用于存储数组和对象以及成员变量，通过new建立的实例都放在堆内存中每一个实体都

有一个内存地址值实体中的变量都有默认初始化值：这是成员变量与局部变量的区别

8种基本数据类型引用数据类型对应的初始化值如下：

byte --------------------------> 0 boolean-------------->false

short------------ -------------> 0 char-------------------->\u0000表示空

int------------------------------> 0 float--------------------->0.0F

long----------------------------> 0L double------------------->0.00

引用数据类型---------------->null

(5).垃圾回收机制

当用关键字new 创建的实体如对象、数组等不再被使用，会在不确定时间由垃圾回收线程将其回收；

C++需要手动回收，而java则是自动回收。

基本应用：

(1).遍历数组

方法1：使用普通for循环

例1.编写一个程序：由键盘录入的方式输入数组长度和数组中各个元素并遍历得到的数组。

import java.util.Scanner;//导入键盘录入类 Scanner
class Demo_1
{
	public static void main(String[] args)
	{
		Scanner sc=new Scanner(System.in);//创建键盘录入的对象sc
		System.out.println("请输入数组长度");
		int num1=sc.nextInt();//存储录入的数子
		int[] arr=new int[num1];// 采用动态初始化的方式创建一个长度为num1的数组 
		for(int i=0;i<num1;i++)
		{
			System.out.println("请输入第"+(i+1)+"个数");
			int num2=sc.nextInt();
			arr[i]=num2;//将输入的数字存到数组中
		}
		bianLi(arr);//调用遍历数组的函数
	}
	public static void bianLi(int[] arr)//遍历数组的函数
	{
		for(int i=0;i<arr.length;i++)
		{
			if(i==arr.length-1)
				System.out.print(arr[i]);
			else
				System.out.print(arr[i]+",");
		}
	}
}

输出效果如下：

分析：length是数组的长度 arr.length表示数组arr[ ]的长度

数组的下标从0开始，所以arr.length-1就可以表示数组arr的下标最大值

方法2：使用增强for循环

import java.util.Scanner;//导入键盘录入类 Scanner
class Demo_2
{
	public static void main(String[] args)
	{
		Scanner sc=new Scanner(System.in);//创建键盘录入的对象sc
		System.out.println("请输入数组长度");
		int num1=sc.nextInt();//存储录入的数子
		int[] arr=new int[num1];// 采用动态初始化的方式创建一个长度为num1的数组 
		for(int i=0;i<num1;i++)
		{
			System.out.println("请输入第"+(i+1)+"个数");
			int num2=sc.nextInt();
			arr[i]=num2;//将输入的数字存到数组中
		}
		bianLi(arr);//调用遍历数组的函数
	}
	public static void bianLi(int[] arr)//遍历数组的函数
	{
		for(int a:arr)
		{
			int b=a;
			System.out.print(b+",");
		}
	}
}

输出结果：

---小结：----------------------------------------------------------------------------------------------------------

遍历数组的两种方法比较：

普通for循环的循环变量也代表着数组的下标，在循环中可以获取到数组的小标值。

然而增强for循环只代表元素本身，并不能取得下标值。

(2).数组的排序：

a.选择排序：

原理：先选择数组中下标为0的位置上的数拿这个位置的值不断和其他下标大于0的位置上的

数值进行比较，如果后项比前项小则交换两数的位置。

比较过程图解

如图所示：原来的顺序是8,5,4,6,3------> 排完序后是3,4,5,6,8

class Demo_3
{
	public static void main(String[] args)
	{
		int[] arr={8,5,4,6,3};//定义数组
		bianLi(arr);//调用数组的遍历函数
		System.out.println("\r\n"+"------------------");
		
		selectSort(arr);//调用选择排序函数
		bianLi(arr);
	}
	public static void bianLi(int[] arr)//遍历数组的函数
	{
		for(int i=0;i<arr.length;i++)
		{
			if(i==arr.length-1)//arr.length是数组的下标最大值
				System.out.print(arr[i]);
			else
				System.out.print(arr[i]+",");
		}
	}
	public static void selectSort(int[] arr)//选择排序函数
	{
		for(int i=0;i<arr.length-1;i++)
		{
			for(int j=i+1;j<arr.length;j++)
			{
				if(arr[j]<arr[i])//如果后项小于前项
				{
					//交换两个数的位置
					int temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
	}
}

程序运行结果：

b.冒泡排序

从下标为0的位置的数开始每相邻的两项进行比较，如果后项小于前项，则交换两数的位置这样可以看到

每轮比较的过程大的值往上"冒",顾名思义为冒泡排序法。

比较过程图解

class Demo_4
{
	public static void main(String[] args)
	{
		int[] arr={8,5,4,6,3};//定义数组
		bianLi(arr);//调用数组的遍历函数
		System.out.println("\r\n"+"------------------");
		
		bubble(arr);//调用冒泡排序函数
		bianLi(arr);
	}
	public static void bianLi(int[] arr)//遍历数组的函数
	{
		for(int i=0;i<arr.length;i++)
		{
			if(i==arr.length-1)//arr.length是数组的下标最大值
				System.out.print(arr[i]);
			else
				System.out.print(arr[i]+",");
		}
	}
	public static void bubble(int[] arr)//冒泡排序函数
	{
		for(int i=0;i<arr.length-1;i++)
		{
			for(int j=0;j<arr.length-1-i;j++)
			{
				if(arr[j+1]<arr[j])//如果后项小于前项
				{
					//交换两个数的位置
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}
}

程序运行结果：

可变参数：在设计方法时，最后一个参数的个数是变动的；可以理解为一维数组。

格式：修饰符返回值类型方法名(类型1,变量1，类型2...变量2)

{

函数体语句;

}

举例：定义两个长度不一样的一维数组，都调用一个求和函数。

class Demo_5
{
	public static void main(String[] args)
	{
		int[] ass={1,3,5,7,9,};//定义数组
		int[] aee={3,4,6};
		int sum1=add(ass);//调用求和函数
		int sum2=add(aee);
		System.out.println("sum1="+sum1);
		System.out.println("sum2="+sum2);
		
	}
	public static int add(int...arr)//求和函数
	{
		int sum=0;
		for(int i=0;i<arr.length;i++)
		{
			sum+=arr[i];
		}
		return sum;
	}
}

程序运行结果

java中数组的定义及其基础应用

猜你喜欢