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

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


数组

一、数组介绍

       数组就相当于一个容器，里面存放相同数据类型的数据。和集合的最大区别是：数组长度固定。

二、数组初始化格式

        ①int[] arr=new int[3];//表示该数组存放了3个int类型的数据

           这会有默认初始化值，均为0；String类型的为null。

        ③int[] arr=new int[]{3,5,6};//该数组存了3个int类型值。

        ②int[] arr={1,2,4,6};//表示数组里面有4个int类型是值，分别是1,2,4,6

           注意：要么指明数组的大小，要么指明数组的值，长度和值不能同时出现。

          数组越界问题：

                   int[] arr=new arr[3];

                   system.out.println(arr[3]);

                 
当数组下标超过数组长度减1（arr.length()-1）时，编译不会出错，但是当运行时，要为数组分配空间，这

                  时数组并不存在该角标的值，会报告ArrayIn
4000
dexOutOfBoundsException异常

          空指针异常：

                    int[] arr=null;

                    system.out.println(arr[1]);

               这时报告空指针NullPointException异常.

               原因在于：引用没有指向任何值，但却还在操作实体。

                 

三、数组遍历

         数组的长度：int length= arr.length()；数组的角标都是从0开始，因此数组最后一个值的角标是length-1。

         

class Demo
{
public void printArray(){
//	   int[] arr=new int[]{1,2,4};
int[] arr=null;
//对数组进行遍历,采用for循环
for(int x=0;x<arr.length;x++)
{
//获取数组中每一个元素
System.out.println("arr["+x+"]="+arr[x]);
}
}
}

四、数组常见操作

      a.
打印：system.out.println(arr);

       打印结果：[I@de6ced

       分析结果：这代表是数组类型的引用，你面存放int型数据。de6ced表示哈希值，即数组存放的内存地址。

       

       b.获取数组中元素的最值

           思路：1.获取最值，需要进行比较，由于最值不知道，因此定义一个临时变量max赋值上0角标或者是数组第一                          个元素。

                      2.遍历数组，取得数组中每一个值，然后和max进行比较，若大于max ，那么将max赋上新值，否则                              max不变。

                      3.数组元素都比较完了最后的max 就是该数组最大值。

                      


               

五、数组排序

        a.选择排序

      

           图例： 

                 

                      


                  

             特点：先取得数组中第一个元素和后面所有元素进行比较，如大于后面的数，就互换位置。

                      再取第二个元素和数组后面所有元素比较

                      每一轮比较完后，都会产生一个最小值在数组头角标上。

                      这是一个嵌套循环。

             代码实现：

public void selectSort()
{//选择排序
int arr[]={2,1,5,3,7};
for(int x=0;x<arr.length-1;x++)//遍历数组
{//arr.length-1数组最后一个元素不用再比较，否则数组越界，因为没有arr[length]这个元素
for(int y=x+1;y<arr.length;y++)
{//都是和后一个元素进行比较
if(arr[x]>arr[y])
{
int temp=arr[x];//第三方变量作为中间转换容器
arr[x]=arr[y];//最小值放在第一个位置。
arr[y]=temp;
}
}
}
}

            b.冒泡排序

                    图例：

             


                   特点：相邻两个元素进行比较，如果符合条件，就进行换位。

                              小值往前，大值往后。

                              一圈完成后，最大值在最后，所有第二圈最后一值可以不参加比较。

                   代码实现：

public void buffleSort()
{//冒泡排序
int[] arr={1,3,2,8,5,0};
for(int x=0;x<arr.length-1;x++)//控制外循环，比较的圈数。
{
//每次进行比较时，都是第一个元素和第二个元素比较。
for(int y=0;y<arr.length-x-1;y++)
{//arr.length-x内循环在逐渐减小，所以后面的元素不用笔记
if(arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}

                     补充：a.排序最快的是希尔排序。

                                b.当数组元素较多时，要考虑排序的效率和性能。

                                c.在堆内存中换位置是比较消耗资源。因此做好是先把要换位置的元素角标在栈内存中记录下来，当比较完后，最后在换位置。

                                d.不管是选择排序还是冒泡排序，都用到了位置置换，那么可以把此功能封装函数，以便复用。

               

六、进制转换

                a.十进制-二进制

                   
原理：除2模2的过程。

                    结果是要倒叙的，才符合二进制。

                    代码体现：

public void toBin(int num)
{//十进制转换二进制
//用StringBuffer存储结果，再将其反转，就是所求数的二进制
StringBuffer sb=new StringBuffer();
while(num>0)
{
sb.append(num%2);//取的模2的值
num=num/2;//不断除2，然后再模2
}
sb.reverse();//最后将其反转，得到二进制
}

         

                     b.十进制-十六进制

                          原理：先拿数与上15，然后进行右移4的操作。（无符号右移>>>高位补上0）

                          图例：

                        


                         代码体现：

public void toHex(int num)
{   //十进制转换十六进制
//用StringBuffer存储结果，再将其反转，就是所求数的十六进制
StringBuffer sb=new StringBuffer();

for(int x=0;x<8;x++){////4字节总共32位，十六进制是4位一组，因此是8
int temp=num & 15;//先进行与比较，存到临时变量中
if(temp>9)        //十六进制在9之后的数用字母表示。
sb.append((char)(temp-10+'A'));
//12-10=2+‘A’=67转换成字母就是C
else
sb.append(temp);
num=num>>>4;//右移4位
}
sb.reverse();
}

                  c.查表法

                   
 原理：将所有元素临时存储起来，并建立好联系。每次与上15之后的值作为索引取查之前建立好的表，然后获得对应的元素。

                     
补充：字符数组初始化的值是"\u0000",就是一个空格。

                       代码体现：

public void toHex2(int num)
{
char[] ch={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'c','D','E','F'};//建立起表的对应关系

//定义一个临时容器
char[] arr=new char[8];//4字节总共32位，十六进制是4位一组，因此是8组
int pos=arr.length;//定义一个指针

while(num!=0)//这个判断可以除去0值。只取有效位。
{
int temp=num & 15;
arr[--pos]=ch[temp];//将与上的数最为角标查表，倒着存

num=num>>>4;
}
}

                    d.封装函数（进制转换）

public void trans(int num,int base,int offset)
{
//base是要相与的数     offset是要移位的数
if(num==0)
return ;
char[] ch={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'c','D','E','F'};//建立起表的对应关系

char[] arr=new char[32];//int型元素是4字节32位
int pos=arr.length;
while(num!=0)
{
int temp=num & base;
arr[--pos]=ch[temp];
num=num>>>offset;
}
}

七、二维数组

                 概述：二维数组可以看出是一维数组，只不过该数组中存放的元素是数组。

                 初始化：int[][] arr=new int[2][];//数组的行数一定要指定，能省略的是列数。

                 原理：二维数组存放的是数组的引用。每个实体都有地址值。

                 图例：