Java 数组

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;(×)