黑马程序员——数组

原创 2015年07月06日 20:27:32

-------android培训、java培训、期待与您交流! ----------

一、数组的定义

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

好处:可以自动给数组中的元素从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是用来在堆内存中产生一个容器实体。


二、内存结构

  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、 数组排序:

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

 输出结果:

         

 

冒泡排序程序:

[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. }  

 输出结果:


五、数组中的数组——二维数组[][]

也称多维数组,这里我们主要讲二维数组。

        格式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

         格式3int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};//每一个一维数组中具体元素都初始化了。

注:一种特殊定义写法:int[]x,y[]; x是一维数组,y是二维数组。



-------android培训、java培训、期待与您交流! ----------


版权声明:本文为博主原创文章,未经博主允许不得转载。

黑马程序员——java基础(面向对象)进制转换、数组、内存分析

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 第四章:java基础(进制转换、数组、内存分析)   本章概述: 第一部分:进制转换 数据...

黑马程序员——数组的Class

1.具有相同维数和元素类型的数组属于同一个类型,即具有相同的Class实例对象。 示例: 2.基本类型的一维数组可以被当作Object类型使用,不能当作Object[ ]类型使用。而非基本类型,...

黑马程序员——ios开发基础之C语言数组、指针与结构体

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 第一讲  数组...

黑马程序员——C语言基础---复杂数据类型(数组,字符串)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 数组的基本概念 一个int类型的变量能保存一个人的年龄,如果想保存整个班的年龄呢? 什...

黑马程序员_JAVA笔记04——数组

------- android培训、java培训、期待与您交流! ---------- 1  数组定义格式:             int[] arr = new int[2]; ...

黑马程序员——Java基础总结(函数、数组)

什么是函数?函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。  函数的格式: 修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,....) { 执行语句; re...

黑马程序员——java学习笔记--数组

数组复制的方法是使用System类提供的arraycopy()方法,其语法如下: System.arraycopy(Object src, int srcPos, Object dest, int ...

黑马程序员——C语言基础---数组1

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------                      第一讲    整型变量修饰符介绍 1、改变整型变量所占...

黑马程序员——数组的相关知识

数组的声明格式里,“数据类型”是声明数组元素的数据类型,常见的类型有整 型、浮点型与字符型等。“数组名”是用来统一这组相同数据类型的元素的名称,其 命名规则和变量的相同,建议读者使用有意义的名称为数组...

黑马程序员——C语言基础(五)数组与字符串

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 一、  数组的基本概念 一个int类型的变量能保存一个人的年龄,如果想保存整...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:黑马程序员——数组
举报原因:
原因补充:

(最多只允许输入30个字)