Java 数组

最新推荐文章于 2023-09-06 16:41:49 发布

Nick_KJ

最新推荐文章于 2023-09-06 16:41:49 发布

阅读量441

点赞数 1

分类专栏： Java 文章标签： java 数组

本文链接：https://blog.csdn.net/Nick_kj/article/details/46792601

版权

Java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Java 数组

数组的定义

数组的内存分配及特点

数组操作常见问题

数组常见操作

数组中的数组

1. 数组的定义

概念：同一种数组类型的集合。其实数组就是一个容器。

数组的好处：

可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式1：

元素类型[] 数组名 = new元素类型[元素个数或数组长度]；

示例：

int[] arr = new int[5] ; //推荐这样写，看的清楚。

int arr[] = new int[5];

格式2：

元素类型[] 数组名 = new元素类型[]{元素，元素，……}; //注意这时[]里没东西

int[] arr1 = new int[]{3,5,1,7};

int[] arr2 = {3,5,1,7};

2. 内存结构

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

1>栈内容：

用于存储局部变量，当数据使用完，所占空间会自动释放。

2>堆内存：

数组和对象，通过new建立的实例都存放在堆内存中。

每一个实体都有内存地址。

实体中的变量都有默认初始化值。

实体不再被使用，会在不确定的时间内被垃圾回收器回收。

3>方法区，4>本地方法栈，5>程序计数器。

eg：

int[] x = new int[3];

int[] y = x; //此时y在栈里，与x一样指向数组的首地址。

y[1] = 89; //问此时x[1]为多少？89

//数组中有一个属性可以直接获取到数组元素个数（length）

//使用方式：数组名称.length

如果直接打印数组名

eg：

System.out.println(arr); // [I@debced（[代表是一维数组，I代表int，@后面是哈

// 希算法得到的16进制的哈希地址。这个地址并不一定，根绝计算机自己算）

排序中最快的是：【希尔排序】

选择排序：

由小到大

for(int x = 0; x<length-1; x++)    //length代表数组长度
	{
		for(int y=x+1 ; y<length ; y++)
		{
			if(arr[x] > arr[y])
			{
				int temp = arr[0];
				arr[x] = arr[y];
				arr[y] = temp;
}
}
}

原理如图：

冒泡排序：

相邻两个元素进行排序，如符合条件换位。

第一次循环结束后，最值出现在最后。

for(int x=0; x<arr.length-1 ; x++)		//-x: 让每一次比较的元素减少；
{								//-1：避免角标越界
	for(int y=0; y<arr.length-1-x ; y++)
	{
		if(arr[y] > arr[y+1])
		{
			int temp = arr[y];
			arr[y] = arr[y+1];
			arr[y+1] = temp;
}
}
}

原理如图：

注：java包中有个排序“Array.sort(arr);可把arr数组直接排序。

数组的查找操作：

public static int getIndex(int[] arr,int key)
{
	for(int x=0; x<arr.length ;x++)
	{
		if(arr[x]==key)
			return x;
}
return -1;
}

折半查找，提高效率，但是必须要保证该数组是有序的数组。

①

public static int halfSearch(int[] arr,int key)
{
		int min,max,mid;
		min = 0;
		max = arr.length-1;
		mid = (max+min)/2;
		while(arr[mid]!=key)   //中间值不等于key
		{
			if(key>arr[mid])
				min = mid+1;
			else if(key<arr[mid])
				max=mid-1;
			else if(min>max)		//为了防止死循环
				return -1;
			mid=(max+min)/2;
}
}

②

public static int halfSearch_2(int[] arr,int key)
{
		int min=0,max=arr.length-1,mid;
		while(min<=max)         //用最大和最小的位置标号
		{
			mid=(max+min)>>1;
			if(key>arr[mid])
				min=mid-1;
			else if(key<arr[mid])
				max= mid-1;
			else
				return mid;
}
return -1;
}

/*
十进制转换成二进制
*/
public static void toBin(int num)
{
		StringBuffer sb = new StringBuffer();
		while(num>0)
		{
			sb.append(num%2);		//暂时存储
			num=num/2;
}
System.out.println(sb.reverse());	//倒叙输出
}
//负数不可用上述方法。负数的话可参照“十→十六”方法②

/*
十进制→十六进制
方法①：
思想：	int n1=num & 15;
			n1-10+’a’;
			int temp = num>>>4;
			temp & 15;
*/
public static void toHex(int num)
{
		for(int x=0; x<8 ;x++)	//8是因为32位，32/4=8
		{
			if(temp>9)
				System.out.println((char)(temp-10+’A’));
			else
				System.out.println(temp);//如想顺序输出参考上StringBuffer
			num=num>>>4;
}
}

方法②：

思想：

0 1 2 3 4 5 6 7 8 9 A B C D E F (16进制中的元素)

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

查表法：将所有的元素临时存储起来，建立对应关系。

每一次&15后的值作为索引去查建好的表，就可以找对应的元素。

public static void toHex(int num)
{
		char[] chs={‘0’,’1’,’2’,’3’,’4’,’5’,’6’,’7’,’8’,’9’,’A’,’B’,’C’,’D’,’E’,’F’};
//定义一个临时容器或StringBuffer
char[] arr = new char[8];
for(int x=0; x<8 ;x++)
{
			int temp=num &15;
			arr[x] = chs[temp];
			num = num>>>4;
}
for(int x= arr.length-1;x>=0;x--)
{
		System.out.print(arr[x]+”,”);
}
}
//里面的for循环会语句会令结果产生一些没必要输出的0，从for循环可修改成
int pos=arr.length;
while（num!=0）
{
int temp = num & 15;
arr[--pos] = chs[temp];	//倒着存储顺着打印
num>>>4;
}
for(int x=pos ; x<arr.length-1;x++)
{
		System.out.print(arr[x]+”,”);
}

注：方法②这种方式同样应用于十进制转二进制，可负数

【方法总结】十→二，十→十六，十→八，都有共性，可提取方法。

//num(十进制数)；base（&的数，1（二），7（八），15（十六），offset为右移位//数
public static void trans(int num , int base, int offset)
{
		if（num==0） System.out.println(0); return;
		char[] chs={‘0’,’1’,’2’,’3’,’4’,’5’,’6’,’7’,’8’,’9’,’A’,’B’,’C’,’D’,’E’,’F’};
		char[] arr= new char[32];
		int pos= arr.length;
		while(num !=0)
{
			int temp = num & base;
			arr[--pos] = chs[temp];
			num = num>>>offset;
}
for(int x=pos;x<arr.length;x++)
			{
				System.out.print(arr[x]);
}
}
/*
	十进制→二进制
*/
public static void toBin(int num)
{
		trans(num,1,1);
}
/*
十进制→八进制
*/
public static void toBa(int num)
{
		trans(num,7,3);
}
/*
十进制→十六进制
*/
public static void toHex(int num)
{
		trans(num,15,4);
}

数组中的数组

二维数组[][]

格式1：int[][] arr= new int[3][2];

定义了名称为arr的二维数组。

二维数组中有3个一维数组

每一个一位数组中有2个元素

一位数组的名称分别为arr[0],arr[1],arr[2]

给第一个一维数组，脚标位赋值为78写法是：arr[0][1]=78;

格式2：int[][] arr = new int[3][];

二维数组中有3个一维数组

每一个一位数组都是默认初始化值null；

可以对这个三个一维数组分别进行初始化。

arr[0]=new int[3];

arr[1]=new int[1];

arr[2]=new int[2];

注：1> 如此时打印 System.out.println（arr）;

结果为：[[I@c17164(@后的值不一定)

打印System.out.println(arr[0]);

结果为：[I@de6ccd(@后的值不一定)

2> 如这么写

int arr[][]=new int[3][]

此时：System.out.println（arr[0]）; 结果为：null。

因为数组为引用型，默认初始化为null。

arr[0]=new int[3];

arr[1]=new int[1];

arr[2]=new int[2];

相当于：

System.out.println（arr.length）; //打印的是二维数组的长度3
System.out.println（arr[0].length）;//打印二维数组中第一个一维数组长//度
int arr1={{3,5,1,7},{2,3,5},{6,1,8,2}};
int sum=0;
for(int x=0;x<arr1.length;x++)
{
	for(int y=0;y<arr1[x].length;y++)
	{
		sum+=arr1[x][y];
}
}

eg：判断

int[] x,y[]; //这种方式相当于 int[] x;int[][] y;

a. x[0]=y;(×)

b. y[0]=x;(√)

c. y[0][0]=x;(×)

d. x[0]0[]=y;(×)

e. y[0][0]=x[0];(√)

f. x=y;(×)