(4)数组

1….数组的定义

:

 

概念

同一种类型数据的集合。其实数组就是一个容器。

数组的好处

可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式1：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

示例：int[] arr = new int[5];

格式2：

元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

 

 

 

2..数组内存结构

 

数组内存结构

 

 

3...内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存

l        用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存

l        数组和对象，通过new建立的实例都存放在堆内存中。

l        每一个实体都有内存地址值

l        实体中的变量都有默认初始化值

l        实体不在被使用，会在不确定的时间内被垃圾回收器回收

方法区，本地方法区，寄存器

 

注释;

java的垃圾回收机制:

这个对象或者实体在堆内存当中一变成垃圾,java虚拟机会自动的去启动垃圾回收机制将堆内存中不在被使用的实体清除掉,不一定会马上执行,会在不定时的时间内清除他

 

堆内存是垃圾回收,栈内存是自动释放

 

 

4…数组静态初始化---创建一个数组实体并给这实体中的每一个位置上都添加了具体的元素

int[] arr = new int[]{3,1,6,5,4};

 

第二种:

int[] arr = newint[5];

              arr[0]= 90;

              arr[1]= 80;

 

5…遍历数组:

 

获取数组中的元素这是最常见的。通常会用到遍历。

 

int[] arr = new int[3];

 

for(int x=0; x<arr.length; x++)    // 这里使用for的原因是这个变量用完就可以消失

              {

                     //sum+= arr[x];

                     System.out.println("arr["+x+"]="+arr[x]+";");      //arr[0]=0;

              }

 

数组中有一个属性可以直接获取到数组元素个数或者叫数组的长度。这个属性是length.

              使用方式：数组名称.length =

 

 

6…获取数组最值:

 

6.1…获取最大值

int[] arr = new int[3]{12,32,45};

 

int max = arr[0];   那个临时变量初始化的值是数组中任意一个元素,因为你要比较的是数组中的元素

 

              for(intx=1; x<arr.length; x++)

              {

                     if(arr[x]>max)

                            max= arr[x];

              }

             

              System.out.println(max);

 

获取最大值的另一种方式。

       可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。

 

              intmax = 0;  o不作为元素存在而是作为角标存在

 

              for(intx=1; x<arr.length; x++)

              {

                     if(arr[x]>arr[max])

                            max= x;

              }

 

 

7…..数组排序

 

7.1….选择排序

 

选择排序可以理解为选择固定一个位置,拿这位置上的值不断得和别人比较,换完位以后还拿这位置上的值继续和别人比,,,       内循环结束一次，最值出现头角标位置上。

 

       publicstatic void selectSort(int[] arr)

       {

              for(int x=0; x<arr.length-1 ; x++)

              {

                     for(inty=x+1; y<arr.length; y++)

                     {

                            if(arr[x]>arr[y])

                            {

                                   inttemp = arr[x];

                                   arr[x]= arr[y];

                                   arr[y]=temp;

                            }

                     }

              }

       }

 

7.2…冒泡排序;相邻的2个元素进行比较,如果符合条件就换位,升序时第一次排序完后发现最大值先出现在最后一位了,小的值都在往前跑,大的往后跑,和冒泡一样,

 

nt[] arr = new int[]{3,1,6,5,4};

 

              for(intx=0; x<arr.length-1; x++)                      {                                                            

for(int y=0; y<arr.length-x-1; y++)             //-x:让每一次比较的元素减少，-1：避免角标越界。 y=0每次内循环都是从0开始比,,arr.length-x第二圈进行比较时y就不用取最后一个元素了,内循环参与比较的元素在逐级的减少,arr.length-x-1是防止arr[y+1]角标越界,当x=0,y=4时y+1就越界了没有5角标元素

                     {

                            if(arr[y]<arr[y+1])大到小

                            {

             

                                   inttemp = arr[y];

                                   arr[y]= arr[y+1];

                                   arr[y+1] = temp;

                    

                            }

                     }

              }

 

注释;

 

以上2种排序性能低,性能低的原因是每一次符合条件我们都会在数组当中对数组内部的元素进行位置的置换,而堆内存中换位置比较消耗资源,,如果他们2个需要换位置的话我先不置换他们的位置,我先把他们需要置换位置的角标以及元素在栈内存中定义2个变量临时记录下来,当我全都比较完了以后我取最终需要换位置的值就可以了原理就是把在堆内存中频繁的换位置转移到栈内存当中,堆内存里面一圈比较我就换一次位置,我把那最大值取到以后我把他放到最后一位,这种方式是在堆内存中换了一次位置,而冒泡就是一圈换好几次位置

 

实际开发中排序一般用Arrays.sort,这个是java语言给我们提供了一个工具用来排序的, Arrays.sort(arr);arr是数组,java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。

 

 

7.3..折半查找数组中的元素

 

折半就是不断的折中找那中间值

 

       /*

       折半查找。提高效率，但是必须要保证该数组是有序的数组。

首先要记录那个头角标和尾角标

       */

       publicstatic int halfSearch(int[] arr,int key)

       {

              intmin,max,mid;

              min= 0;

              max= arr.length-1;

              mid= (max+min)/2; 

 

              //折半的动作只要没有找到他会重复的去做,,,循环的条件是你只要找到的中间值和我那个key不相等就继续折半

              while(arr[mid]!=key)

              {

                     if(key>arr[mid])

                            min= mid + 1;

                     elseif(key<arr[mid])

                            max= mid - 1;

                     //以上2个都不满足的话就相当于找到了就是return mid;

 

                     //上面的(2)处是折半了一次,比完以后下面就继续折半

                     if(min>max)    //说明没有折半的可能了

                            return-1;

                     mid= (max+min)/2;

              }

              returnmid;

       }

 

 

8….数组进制转换

 

       /*

       十进制-->2进制。就是不断的除2.%2的过程重复的去做

       */

       publicstatic void toHex(int num)

       {

 

              StringBuffersb = new StringBuffer();

 

              while(num>0)  //这个二进制求的时候不能是负数,因为必须得num>0

              {

                    

                     System.out.println(num%2);

                     num=num/2;

                    

              }

              System.out.println(sb.reverse());  //StringBuffer的数据反转

 

       }

 

/*

       十进制-->十六进制。原理:就是不断的除16.%16的过程重复的去做

                            另一种方法:我先取到最低4位,然后我算一下他的值,然后我在 与& 下一个4位我再算他的值

       */

 

       publicstatic void toHex(int num)

       {

 

              StringBuffersb = new StringBuffer();

 

//循环的次数是8的原因是:32位里面有8个4位的(4个数字)0000,最多8次

 

              for(intx=0; x<8; x++)

              {

                     inttemp = num & 15;

                     if(temp>9)

                           

                            sb.append((char)(temp-10+'A'));

                     else

                            //System.out.println(temp);

                            sb.append(temp);

 

                     num  = num >>> 4;

              }

              System.out.println(sb.reverse());

 

       }

 

 

10…二维数组

 

10.1...二维数组:往数组里面存的还是一个数组,把数组作为元素存到了另一个数组当中

 

10.2...二维数组的初始化方式第一种

 

int[] arr = new int[3];//一维数组。

 

int[][] arr = new int[3][4];    //定义了名称为arr的二维数组。二维数组中有3个一维数组。每一个一维数组中有四个元素。

                               // 3是二维数组的长度,4是二维数组中每一个一维数组的长度

//二维数组中第一个一维数组的名字是arr[0],,,[]代表二维数组

 

二维数组的初始化方式第二种

 

int[][] arr = new int[3][];  这个3必须得写,因为你定义的是二维数组,3代表的是二维数组的长度,但是这个二维数组当中一维数组的长度却不确定

 

             

System.out.println(arr[0]);

 

结果是; null,二维数组里面存了3个一维数组,第一个一维数组是arr[0],而这3个一维数组没有初始化过,所以他用的是默认初始化,而数组是引用数据类型,所以初始化值都是null,arr[0],arr[1],arr[2]这三个变量都没有任何的小数组指向,

 

10.3…二维数组的静态初始化

 

数组有静态初始化方式,就是直接指定元素内容

 

int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};    {3,5,1,7}是一维数组

 

问题:什么时候定义二维数组

数据多了我们需要进行容器的存储,要存到数组里去,可是这些数据之间是有关系的,我们应该单独把这个有关系的数据单独封到一个组里去,建一个数组,里面有好多组数据,然后就把这些组再封装到一个大组里面去就成了二维数组