码迷，mamicode.com
首页 > 编程语言 > 详细

黑马程序员——数组

时间：2015-12-03 00:07:53      阅读：276      评论：0      收藏：0      [点我收藏+]

标签：

一、概念

        同一种类型数据的集合。简单的来说就是一容器，用来装东西的。

        使用数组的好处：可以自动给数组中的元素从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.println(arr);得到的结果是一个哈希值，也叫地址值。

        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已经定义好了一种排序方式，在开发使用中，直接调用即可。排序的方式有很多，其中最快的排序方式为希尔排序。

下面是我自己敲的选择和冒泡两种排序方式的程序：

        选择排序程序：

[java] view plaincopy
 
  1. //使用选择排序方式对指定的数组进行排序  
  2.   
  3. class  Demo  
  4. {  
  5.     public static void main(String[] args)   
  6.     {  
  7.         int[] arr= {1,11,5,3,9,55,23,67,18};  
  8.         //输出原数组  
  9.         printArray(arr);  
  10.         //调用排序方法  
  11.         selectSort(arr);  
  12.         //输出排序后的数组  
  13.         printArray(arr);  
  14.     }  
  15.       
  16. /* 
  17. 选择排序 
  18. 1、先用0角标上的元素依次与其他元素进行比较，将较小值元素存放到0角标。 
  19. 2、然后再拿1角标上的元素依次进行比较，以此类推。 
  20. */  
  21.     public static void selectSort(int[] arr)  
  22.     {  
  23.         //外循环遍历数组  
  24.         for (int x=0;x<arr.length-1;x++)  
  25.         {  
  26.             //内循环比较大小  
  27.             for (int y=x+1;y<arr.length;y++)  
  28.             {  
  29.                 //如果后一个元素比拿去比较的元素大，就交换两元素位置  
  30.                 if(arr[x]>arr[y])  
  31.                 {  
  32.                     //arr[x]=arr[y];  
  33.                     //arr[y]=temp;  
  34.                     swap(arr,x,y);  
  35.                 }     
  36.             }  
  37.         }  
  38.     }  
  39.   
  40.     //遍历数组  
  41.     public static void printArray(int[] arr)  
  42.     {  
  43.         System.out.print("[");  
  44.         for (int x=0;x<arr.length;x++)  
  45.         {  
  46.             if(x!=arr.length-1)  
  47.                 System.out.print(arr[x]+",");  
  48.             else  
  49.                 System.out.print(arr[x]+"]");  
  50.         }  
  51.         //换行  
  52.         System.out.println();  
  53.     }  
  54.   
  55.     //互换方法  
  56.     public static void swap(int[] arr,int a,int b)  
  57.     {  
  58.         arr[a]=arr[a]^arr[b];  
  59.         arr[b]=arr[a]^arr[b];  
  60.         arr[a]=arr[a]^arr[b];  
  61.     }  
  62. }  

 输出结果：

    技术分享     

 

冒泡排序程序：

[java] view plaincopy
 
  1. //使用冒泡排序方式对指定程序进行排序  
  2.   
  3. class Demo1   
  4. {  
  5.     public static void main(String[] args)   
  6.     {  
  7.         int arr[]={22,63,89,13,6};  
  8.         //打印原数组  
  9.         printArray(arr);  
  10.         //调用排序方法  
  11.         bubbleSort(arr);  
  12.         //打印排序后的数组  
  13.         printArray(arr);  
  14.     }  
  15.   
  16.     /* 
  17.     冒泡排序 
  18.     1、先从头角标相邻两个元素之间进行比较，将较大值存放在后一个元素中，然后再与后一个元素的进行比较，直至最大值存放到最后一个元素中。 
  19.     2、再重复1操作，每次计较次数减一，一圈比完后存放的较大元素不再参与比较。 
  20.     */  
  21.   
  22.     public static void bubbleSort(int[] arr)  
  23.     {  
  24.         for (int x=0;x<arr.length-1;x++)  
  25.         {  
  26.             for (int y=0;y<arr.length-1-x;y++)//-x:让没每一次比较的元素减少。-1：避免角标越界。  
  27.             {  
  28.                 if(arr[y]>arr[y+1])  
  29.                     swap(arr,y,y+1);  
  30.             }  
  31.         }  
  32.     }  
  33.     //遍历数组  
  34.     public static void printArray(int[] arr)  
  35.     {  
  36.         System.out.print("[");  
  37.         for (int x=0;x<arr.length;x++)  
  38.         {  
  39.             if(x!=arr.length-1)  
  40.                 System.out.print(arr[x]+",");  
  41.             else  
  42.                 System.out.print(arr[x]+"]");  
  43.         }  
  44.         //换行  
  45.         System.out.println();  
  46.     }  
  47.   
  48.     //互换方法  
  49.     public static void swap(int[] arr,int a,int b)  
  50.     {  
  51.         arr[a]=arr[a]^arr[b];  
  52.         arr[b]=arr[a]^arr[b];  
  53.         arr[a]=arr[a]^arr[b];  
  54.     }  
  55. }  

 输出结果

技术分享

 

2、 折半查找

程序：

[java] view plaincopy
 
  1. /* 
  2. 需求：将一个已知元素插入到一个有序数组中，要求不改变数组顺序，打印元素应该插入数组位置的角标。 
  3. 思路：1、可以利用折半查找的方式，先定义两个变量，一个初始化0角标，作为最小值，一个初始化为最后一个角标，作为最大值， 
  4.         再定义一个变量，存储最小值与最大值的一半，也就是中间位置，然后将已知元素与中间值位元素进行比较。 
  5.       2、如果比中间值元素大，则将最小值变为中间值加1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复 
  6.       3、如果比中间值元素小，则将最大值变为中间值减1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复 
  7. */  
  8. class  HalfSearch  
  9. {  
  10.     public static void main(String[] args)   
  11.     {  
  12.         int[] arr={2,6,9,11,15,19,22,30};  
  13.         //打印数组  
  14.         printArray(arr);  
  15.         int key=20;  
  16.         //用第一种折半方式输出插入的角标值  
  17.         System.out.println("当key=20在数组arr中插入的角标位置是："+halfSearch1(arr,key));  
  18.         key=1;  
  19.         //用第二种折半方式输出插入的角标值  
  20.         System.out.println("当key=1在数组arr中插入的角标位置是："+halfSearch2(arr,key));  
  21.     }  
  22.   
  23.     //折半查找<一>  
  24.     public static int halfSearch1(int[] arr,int key)  
  25.     {  
  26.         int min=0,max=arr.length-1,mid=(max+min)/2;  
  27.         while(key!=arr[mid])  
  28.         {  
  29.             if(min>max)  
  30.                 return min;  
  31.             else if(key>arr[mid])  
  32.                 min=mid+1;  
  33.             else   
  34.                 max=mid-1;  
  35.             mid=(max+min)>>>1;//折半操作             
  36.         }  
  37.         return mid;   
  38.     }  
  39.   
  40.     //折半查找<二>  
  41.     public static int halfSearch2(int[] arr,int key)  
  42.     {  
  43.         int min=0,max=arr.length-1,mid;  
  44.   
  45.         while(min<max)  
  46.         {  
  47.             mid=(max+min)>>>1;//折半操作  
  48.             if(key>arr[mid])  
  49.                 min=mid+1;  
  50.             else if(key<arr[mid])  
  51.                 max=mid-1;  
  52.             else  
  53.                 return mid;  
  54.         }  
  55.         return min;   
  56.     }  
  57.   
  58.     //遍历数组  
  59.     public static void printArray(int[] arr)  
  60.     {  
  61.         System.out.print("[");  
  62.         for (int x=0;x<arr.length;x++)  
  63.         {  
  64.             if(x!=arr.length-1)  
  65.                 System.out.print(arr[x]+",");  
  66.             else  
  67.                 System.out.print(arr[x]+"]");  
  68.         }  
  69.         //换行  
  70.         System.out.println();  
  71.     }  
  72. }  

运行结果：

技术分享

 

3、 进制转换

十进制转换为二进制、八进制、十六进制的小程序：

[java] view plaincopy
 
  1. /* 
  2. 使用查表法将十进制转换为二进制、八进制、十六进制 
  3. */  
  4. class  Conversion  
  5. {  
  6.     public static void main(String[] args)   
  7.     {  
  8.         int num=60;  
  9.   
  10.         toBin(num);  
  11.   
  12.         toOct(0);  
  13.   
  14.         toHex(-num);  
  15.     }  
  16.   
  17.     //转换为二进制  
  18.     public static void toBin(int num)  
  19.     {  
  20.         conversion(num,1,1);  
  21.     }  
  22.   
  23.     //转换为八进制  
  24.     public static void toOct(int num)  
  25.     {  
  26.         conversion(num,7,3);  
  27.     }  
  28.   
  29.     //转换为十六进制  
  30.     public static void toHex(int num)  
  31.     {  
  32.         conversion(num,15,4);  
  33.     }  
  34.     //转换  
  35.     public static void conversion(int num,int diwei,int yiwei)  
  36.     {  
  37.         //如果num等于0，结果输出为0  
  38.         if(num==0)  
  39.         {  
  40.             System.out.println("num="+0);  
  41.             return;  
  42.         }  
  43.         //定义一个包含二进制、八进制、十六进制的表  
  44.         char[] chs={‘0‘,‘1‘,‘2‘,‘3‘,‘4‘,‘5‘,‘6‘,‘7‘,  
  45.                     ‘8‘,‘9‘,‘A‘,‘B‘,‘C‘,‘D‘,‘E‘,‘F‘,};  
  46.   
  47.         //定义一个临时容器  
  48.         char[] arr=new char[32];  
  49.   
  50.         //定义一个操作数组的指针  
  51.         int pos=arr.length;  
  52.   
  53.         //利用与低位最大值的方式取出低位，存到临时数组中  
  54.         while(num!=0)  
  55.         {  
  56.             arr[--pos]=chs[num&diwei];//--pos倒着往临时容器里存  
  57.             num >>>=yiwei; //无条件右移相应位数  
  58.         }  
  59.           
  60.         //打印转换后的结果  
  61.         for(int x=pos;x<arr.length; x++)  
  62.             System.out.print(arr[x]);  
  63.           
  64.         //换行  
  65.         System.out.println();  
  66.     }  
  67. }  

 输出结果：

技术分享

黑马程序员——数组

标签：

原文地址：http://www.cnblogs.com/android-java-lan/p/5014549.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！