您的位置:首页 > 编程语言 > Java开发

4、Java数组

2015-11-23 21:48 274 查看

一、概念

同一种类型数据的集合,是一种容器

(使用数据的好处:可以自动给数组中的元素从0开始编号,方便操作这些元素。)

二、一维数组

        格式1:元素类型 [ ]数组名 = new元素类型
[元素个数或数组长度] ;
                  如: int []  arr = new int [3]; 也可以写成: int
arr[] = new int[3];
        格式2:元素类型 []数组名 = new元素类型
[ ]{元素1,元素2,…};
                  如: int []  arr = new int []{1,2,3,4,5};
        还有一种简写的静态初始化格式:如: int [] arr={1,2,3,4,5};
        其中:new是用来在堆内存中产生一个容器实体。
数组也被称为引用数据类型。在内存中的分配如下图:
          


注:1.System.out.pintln(arr);//[I@2a139a55 得到的结果是一个哈希值,也叫地址值。
       2.数组在堆中开辟空间后,就有了默认的初始化值,如:int默认0;boolean默认false。

内存小知识:
        Java程序在运行时,需要在内存中的分配空间。为了提高运算效率,有对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
        栈内存:用于存储局部变量,当数据使用完,所占空间会自动释放。
        堆内存:1、数组和对象,通过new建立的实例都存放在堆内存中。
                      2、每一个实体都有内存地址值。
                      3、实体中的变量都有默认初始化值。
                      4、实体不在被使用,会在不确定的时间内被垃圾回收器回收。

三、数组操作常见问题

   
1、数组脚标越界异常(ArrayIndexOutOfBoundsException)。例:
            
int[] arr = new int[2];
              System.out.println(arr[3]);
            访问到了数组中的不存在的脚标时发生。
   
2、空指针异常(NullPointerException)。例:
            int[]arr = null;
             System.out.println(arr[0]);
            arr引用没有指向实体,却在操作实体中的元素时。

四、多维数组(数组中的数组

也称多维数组,这里我们主要讲二维数组。
        格式1: int[][] arr= new int[3][2];
        解释:以上格式表示定义了名称为arr的二维数组。有3个一维数组,每一个一维数组中有2个元素。一维数组的名称分别为arr[0],arr[1],arr[2]。给第一个一维数组1脚标位赋值为78写法是:arr[0][1]
= 78。
        格式2: int[][] arr= new int[3][];
         注:此种格式中每个一维数组都是默认初始化值null。
        格式3:int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};//每一个一维数组中具体元素都初始化了。
注:一种特殊定义写法:int[]x,y[]; x是一维数组,y是二维数组。
二维数组在内存中的分配情况示例:



五、数组常见操作

1、 数组排序:

        常见的排序方式:冒泡排序和选择排序。在Java已经定义好了一种排序方式,在开发使用中,直接调用即可。排序的方式有很多,其中最快的排序方式为希尔排序。
下面是我自己敲的选择和冒泡两种排序方式的程序:

        选择排序程序:

<span style="font-size:12px;">    //使用选择排序方式对指定的数组进行排序

class  Demo
{
public static void main(String[] args)
{
int[] arr= {1,11,5,3,9,55,23,67,18};
//输出原数组
printArray(arr);
//调用排序方法
selectSort(arr);
//输出排序后的数组
printArray(arr);
}

/*
选择排序
1、先用0角标上的元素依次与其他元素进行比较,将较小值元素存放到0角标。
2、然后再拿1角标上的元素依次进行比较,以此类推。
*/
public static void selectSort(int[] arr)
{
//外循环遍历数组
for (int x=0;x<arr.length-1;x++)
{
//内循环比较大小
for (int y=x+1;y<arr.length;y++)
{
//如果后一个元素比拿去比较的元素大,就交换两元素位置
if(arr[x]>arr[y])
{
//arr[x]=arr[y];
//arr[y]=temp;
swap(arr,x,y);
}
}
}
}

//遍历数组
public static void printArray(int[] arr)
{
System.out.print("[");
for (int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]+"]");
}
//换行
System.out.println();
}

//互换方法
public static void swap(int[] arr,int a,int b)
{
arr[a]=arr[a]^arr[b];
arr[b]=arr[a]^arr[b];
arr[a]=arr[a]^arr[b];
}
}  </span>


冒泡排序程序:

//使用冒泡排序方式对指定程序进行排序

class Demo1
{
public static void main(String[] args)
{
int arr[]={22,63,89,13,6};
//打印原数组
printArray(arr);
//调用排序方法
bubbleSort(arr);
//打印排序后的数组
printArray(arr);
}

/*
冒泡排序
1、先从头角标相邻两个元素之间进行比较,将较大值存放在后一个元素中,然后再与后一个元素的进行比较,直至最大值存放到最后一个元素中。
2、再重复1操作,每次计较次数减一,一圈比完后存放的较大元素不再参与比较。
*/

public static void bubbleSort(int[] arr)
{
for (int x=0;x<arr.length-1;x++)
{
for (int y=0;y<arr.length-1-x;y++)//-x:让没每一次比较的元素减少。-1:避免角标越界。
{
if(arr[y]>arr[y+1])
swap(arr,y,y+1);
}
}
}
//遍历数组
public static void printArray(int[] arr)
{
System.out.print("[");
for (int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]+"]");
}
//换行
System.out.println();
}

//互换方法
public static void swap(int[] arr,int a,int b)
{
arr[a]=arr[a]^arr[b];
arr[b]=arr[a]^arr[b];
arr[a]=arr[a]^arr[b];
}
}


       折半查找

/*
需求:将一个已知元素插入到一个有序数组中,要求不改变数组顺序,打印元素应该插入数组位置的角标。
思路:1、可以利用折半查找的方式,先定义两个变量,一个初始化0角标,作为最小值,一个初始化为最后一个角标,作为最大值,
再定义一个变量,存储最小值与最大值的一半,也就是中间位置,然后将已知元素与中间值位元素进行比较。
2、如果比中间值元素大,则将最小值变为中间值加1,继续取最小值与最大值的中间值元素与已经元素进行比较,以此反复
3、如果比中间值元素小,则将最大值变为中间值减1,继续取最小值与最大值的中间值元素与已经元素进行比较,以此反复
*/
class  HalfSearch
{
public static void main(String[] args)
{
int[] arr={2,6,9,11,15,19,22,30};
//打印数组
printArray(arr);
int key=20;
//用第一种折半方式输出插入的角标值
System.out.println("当key=20在数组arr中插入的角标位置是:"+halfSearch1(arr,key));
key=1;
//用第二种折半方式输出插入的角标值
System.out.println("当key=1在数组arr中插入的角标位置是:"+halfSearch2(arr,key));
}

//折半查找<一>
public static int halfSearch1(int[] arr,int key)
{
int min=0,max=arr.length-1,mid=(max+min)/2;
while(key!=arr[mid])
{
if(min>max)
return min;
else if(key>arr[mid])
min=mid+1;
else
max=mid-1;
mid=(max+min)>>>1;//折半操作
}
return mid;
}

//折半查找<二>
public static int halfSearch2(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 min;
}

//遍历数组
public static void printArray(int[] arr)
{
System.out.print("[");
for (int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]+"]");
}
//换行
System.out.println();
}
}


       进制转换(十进制转换为二进制、八进制、十六进制的小程序):

/*
使用查表法将十进制转换为二进制、八进制、十六进制
*/
class  Conversion
{
public static void main(String[] args)
{
int num=60;

toBin(num);

toOct(0);

toHex(-num);
}

//转换为二进制
public static void toBin(int num)
{
conversion(num,1,1);
}

//转换为八进制
public static void toOct(int num)
{
conversion(num,7,3);
}

//转换为十六进制
public static void toHex(int num)
{
conversion(num,15,4);
}
//转换
public static void conversion(int num,int diwei,int yiwei)
{
//如果num等于0,结果输出为0
if(num==0)
{
System.out.println("num="+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)
{
arr[--pos]=chs[num&diwei];//--pos倒着往临时容器里存
num >>>=yiwei; //无条件右移相应位数
}

//打印转换后的结果
for(int x=pos;x<arr.length; x++)
System.out.print(arr[x]);

//换行
System.out.println();
}
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: