黑马程序员——数组

原创 2015年11月18日 09:51:52

黑马程序员--数组

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

数    组

一、定义
数组:同一个类型数据的集合,就是一个容器。优点:从0自动编号,方便操作。

二、格式
(一)一维数组
格式1:元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
例:int[] arr = new int[4]; 或写成 int arr[] = new int[4];

格式2:元素类型[] 数组名 = new 元素类型[]{元素1,元素2,...};(数据明确时使用) 
例:int[] arr = new int[]{3,1,6}; 

格式3:元素类型[] 数组名 = {元素1,元素2,...};(简写的静态初始化格式)
例:int[] arr = {3,1,6};

一维数组内存图:


(二)二维数组
格式1:int[][] arr = new int[3][2];
上述格式表示:二维数组中有3个一维数组,每个一维数组包含2个元素; 

格式2:int[][] arr = new int[3][];
上述格式表示:每个一维数组的默认初始化值为null。

格式3:int[][] arr = {{3,8,1},{1,2},{3},...};
上述格式表示:每一个一维数组中具体元素都已经初始化。

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

二维数组内存图:
PS:
1、数据类型包括基本类型和引用类型。数组就是一种引用类型
2、内存结构:java中有5个区域存储数据:栈、堆、方法区、本地方法区、寄存器; 
栈内存:存储局部变量,数据用完,自动释放。
堆内存:  a 数组和对象,通过new建立的实例都在其中;
        b 实体中的变量都有默认初始化值;
c 每个实体都有内存地址值;
d 实体不再被使用后,启动垃圾回收机制。

三、数组常见问题
1、ArrayIndexOutOfBoundsException:数组角标越界异常,访问到数组中不存在的角标

  1. class ArrayDemo1  
  2. {  
  3.     public static void main(String[] args)   
  4.     {  
  5.         int[] arr = new int[2];  
  6.         System.out.println(arr[2]);  
  7.     }  
  8. }  

运行结果:

2、NullPointerException:空指针异常

  1. class ArrayDemo2  
  2. {  
  3.     public static void main(String[] args)   
  4.     {  
  5.         int[] arr = null;  
  6.         System.out.println(arr[0]);  
  7.     }  
  8. }  

运行结果:

四、数组常见操作

1、数组排序:常见排序有两种:选择排序、冒泡排序。

选择排序:头角标值和所有值进行比较,内循环结束一次,最值出现在头角标位置上。    

冒泡排序:相邻值比较,最值出现在末角标。

java在开发中常使用已定义好的一种排序方法:Arrays.sort(arr);

下面是数组常用代码:

  1. /* 
  2. 选择排序: 
  3. */  
  4. public class ArraySelect1 {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         int[] arr = {1,12,45,17,45,78,72};  
  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.                     swap(arr,x,y);  
  33.                 }  
  34.             }  
  35.         }  
  36.     }  
  37.     //定义换值方法,arr也是未知变量   
  38.     public static void swap(int[] arr,int a,int b)   
  39.     {  
  40.         int temp = arr[a];  
  41.         arr[a] = arr[b];  
  42.         arr[b] = temp;  
  43.     }  
  44.     //设置打印格式   
  45.     public static void printArray(int[] arr)  
  46.     {  
  47.         System.out.print("[");  
  48.         for(int x=0;x<arr.length;x++)  
  49.         {  
  50.             if(x!=arr.length-1)  
  51.             System.out.print(arr[x]+",");  
  52.             else  
  53.             System.out.println(arr[x]+"]");  
  54.         }  
  55.     }  
  56. }  
输出代码:

  1. /* 
  2. 冒泡排序 
  3. */  
  4. public class ArraySelect2 {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         int[] arr = {1,12,45,17,45,78,72};  
  8.         //输出原数组   
  9.         printArray(arr);  
  10.         //进行选择排序   
  11.         bubbleSort(arr);  
  12.         //输出排序后数组   
  13.         printArray(arr);  
  14.           
  15.     }  
  16.     /* 
  17.      * 思路:比较相邻项 最值在尾部 
  18.      */  
  19.   
  20.     public static void bubbleSort(int[] arr)  
  21.     {  
  22.         for(int x=0;x<arr.length-1;x++)  
  23.         {  
  24.             for(int y =0;y<arr.length-x-1;y++)//-x:让每一次比较的元素减少;-1:避免角标越界   
  25.             {  
  26.                 if(arr[y]>arr[y+1])  
  27.                 {  
  28.                     swap(arr,y,y+1);  
  29.                 }  
  30.             }  
  31.         }  
  32.     }  
  33.     //定义换值方法,arr也是未知变量   
  34.     public static void swap(int[] arr,int a,int b)   
  35.     {  
  36.         int temp = arr[a];  
  37.         arr[a] = arr[b];  
  38.         arr[b] = temp;  
  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.println(arr[x]+"]");  
  50.         }  
  51.     }  
  52. }  

输出结果:


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



  1. /* 
  2.  * 需求:利用查表法将十进制转换为二进制、八进制、十六进制。 
  3.  * 思路:1、进制在进行与运算后,会获取相对应的值。 
  4.  *      2、数组是同一种类型数据的集合,元素和角标具有对应关系; 
  5.  *      3、将进制封装进数组中。 
  6.  */  
  7. public class TranstionDemo {  
  8.     public static void main(String[] args)  
  9.     {  
  10.         toBin(0);  
  11.         show();  
  12.         toOct(9);  
  13.         show();  
  14.         toHex(45);  
  15.     }  
  16.     //十进制转二进制   
  17.     public static void toBin(int num)  
  18.     {  
  19.         trans(num,1,1);  
  20.     }  
  21.     //十进制转八进制   
  22.     public static void toOct(int num)  
  23.     {  
  24.         trans(num,7,3);  
  25.     }  
  26.     //十进制转十六进制   
  27.     public static void toHex(int num)  
  28.     {  
  29.         trans(num,15,4);  
  30.     }  
  31.       
  32.     public static void trans(int num,int base,int offset)  
  33.     {  
  34.         //因为所有进制的0值都是0,故单独定义   
  35.         if(num==0)  
  36.         {  
  37.             System.out.print(0);  
  38.             return;  
  39.         }  
  40.         //定义数据库表   
  41.         char[] chs = {'0','1','2','3',  
  42.                       '4','5','6','7',  
  43.                       '8','9','A','B',  
  44.                       'C','D','E','F'};  
  45.         //定义临时容器。因为一个char有32个二进制位,故依最多位值设置数组。   
  46.         char[] arr = new char[32];  
  47.           
  48.         //指针代表存入值的位,这样存可使值倒着输出   
  49.         int pos = arr.length;  
  50.           
  51.         //只运算有效位,提高运算效率。   
  52.         while(num!=0)   
  53.         {  
  54.             int temp = num & base;  
  55.               
  56.             //--pos是存入角标的移位动作,防止覆盖   
  57.             arr[--pos] = chs[temp];  
  58.               
  59.             //右移位数   
  60.             num=num>>>offset;    
  61.         }  
  62.           
  63.         //从pos位开始遍历,可以只输出有效位   
  64.         for(int x=pos;x<arr.length;x++)   
  65.         {  
  66.             System.out.print(arr[x]);  
  67.         }         
  68.     }  
  69.     //定义输出函数   
  70.     public static void show()  
  71.     {  
  72.         System.out.println();  
  73.     }  
  74. }  
输出结果:


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

相关文章推荐

黑马程序员——函数及数组

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

黑马程序员——用二维数组打印螺旋方阵和螺旋矩阵

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

黑马程序员——java第四天:基础语法(函数、数组)

函数android培训、java培训、期待与您交流! ----------/div>函数(方法):有特定功能的一小段代码程序。函数的格式:         修饰符 返回值类型 函数名(参数类型 形式参...

黑马程序员10——结构和数组相关概念和重点

---------------------- Windows Phone 7手机开发、.Net培训、 期待与您交流!---------------------- 结构 结构...

黑马程序员——数组的Class

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

黑马程序员——Java(数组)

-----Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 一:数组定义:                数组是相同类型数据的集合,描述的是相同类型的若干...

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

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

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

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 一、数组的概述     数组中的元素都是同一种类型。数组的长度在创建时确定,并且在创建后不变。...

黑马程序员——javase基础--数组

——- android培训、java培训、期待与您交流! ———-  一、概念 同一种类型数据的集合。 使用数组的好处:可以自动给数组中的元素从0开始编号,方便操...

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

------- android培训、java培训、期待与您交流! ---------- 一、      数组概述: 1、定义:数组就是同一种数据类型的集合。其实数组就是一个容器。 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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