黑马程序员_数组的理解

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

 

数组的定义

1.概念

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

2.数组的好处

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

3.数组的格式一般有：

 格式1： 元素类型[].数组名 = new 元素类型[元素个数或数组长度]；

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

 格式2： 元素类型[] 数组名= new 元素类型[]｛元素，元素，......｝;

 示例：int [] arr =new int[]{1，3，4，5}；

            int [] arr =｛1，3，4，6｝；

内存结构：

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

栈内存：

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

堆内存：

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

每一个实体都有内存地制值

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

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

数组中的常见操作：

1，数组的遍历

       int[] arr =new int[3];

       int[] arr ={5,7,9,2,6,9};//明确了数组的类型和长度，并明确了数组中元素的内容。

       int[] arr1 = new int[]{5,7,9};

       //方便获取数组中的元素个数的方式，可以使用数组实体一个属性。length

       System.out.println("len:"+arr.length); 

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

       {

              if(x%2==1)

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

       }

      这就是遍历的思想，获取数组中的元素，通常会用到遍历。

2，获取最值

 获取数组中的最大值。
 思路：
 1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
 通过一个变量进行临储。
 2，让数组中的每一个元素都和这个变量中的值进行比较。
 如果大于了变量中的值，就用该该变量记录较大值。
 3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

 步骤：
 1，定义变量。初始化为数组中任意一个元素即可。
 2，通过循环语句对数组进行遍历。
 3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；
 
 需要定义一个功能来完成。以便提高复用性。
 1，明确结果，数组中的最大元素 int。
 2，未知内容：一个数组。int[]

实现代码

public static int getMax(int[] arr)
{
  int max = arr[0];

  for(int x=1; x<arr.length; x++)
{
   if(arr[x]>max)
    max = arr[x];
}
  return max;

}

 /*
 获取最大值的另一种方式。
 可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。
 */
 public static int getMax_2(int[] arr)
{
  int max = 0;

  for(int x=1; x<arr.length; x++)
{
   if(arr[x]>arr[max])
    max = x;
}
  return arr[max];
}
/*
获取最小值。
*/
 public static int getMin(int[] arr)

{
  int min = 0;
  for(int x=1; x<arr.length; x++)
{
   if(arr[x]<arr[min])
    min = x;
}
  return arr[min];
}

 //获取double类型数组的最大值。因为功能一致，所以定义相同函数名称。以重载形式存在。

 public static void main(String[] args)

{
  int[] arr ={5,1,6,4,2,8,9};

  int max = getMax_2(arr);
  int min = getMin(arr);
  System.out.println("max="+max);
  System.out.println("min="+min);

  boolean[] ar = new boolean[3];

  System.out.println(ar[1]);
}

}

同样有另外一种方式获取最大值

Public staticint getMax(int[] arr)

{

Int maxIndex=0;//初始化为数组中一个元素的角标

For(int x=1;x<arr.length;x++)

{

If(arr[x]>arr[maxIndex])

maxIndex=x;

}

Return arr[maxIndex];

}

------------------

排序

选择排序：

 

 

用数组中第一个角标的元素与数组中第二个角标的元素进行比较，发现9比6大，进行位置置换，此处应该定义一个三方变量，用来记录住置换过程的元素值，然后再用第一个角标的元素与下一个角标元素进行比较，按照全面的原则进行置换位置，如果前者小于后者，则不置换位置，一次比较，当第一轮结束之后第一个角标出能取的该数组中最小的元素的值，然后再用第一个角标的元素开始和下一个角标的元素进行比较，同理，当第二轮结束后，第二个角标处获取了该数组中的第二小的值。所以我们发现当依次这样比较下去，就可以对数组中的元素进行排序，当比较到arr.length-1元素时，发现只剩下这一个元素，没有其他元素和它进行比较了。

思路：

1、首先定义一个功能函数对数组进行排序，

2、明确结果，没有返回值，因为它只是对数组进行排序的一个动作，明确是否有未知内容参与运算，有，数组类型int[] arr

实现代码：

class Test2
{

 /*
 选择排序。
 内循环结束一次，最值出现头角标位置上。
 */
 public static void selectSort(int[] arr)
 {
  for (int x=0; x<arr.length-1 ; x++)
  {
   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;
     */
     swap(arr,x,y);
    }
   }
  }
 }

 

冒泡排序：

 

 实现代码：

/*
 冒泡排序
 */

 public static void bubbleSort(int[] arr)
 {
  for(int x=0; x<arr.length-1; x++)
  {         
   for(int y=0; y<arr.length-x-1; y++)//-x:让每一次比较的元素减少，-1：避免角标越界。

  {
    if(arr[y]<arr[y+1])
    {
     /*
     int temp = arr[y];
     arr[y] = arr[y+1];
     arr[y+1] = temp;
     */
     swap(arr,y,y+1);
    }
   }
  }
 }

 /*
 发现无论什么排序。都需要对满足条件的元素进行位置置换。
 所以可以把这部分相同的代码提取出来，单独封装成一个函数。
 */
 public static void swap(int[] arr,int a,int b)
 {
  int temp = arr[a];
  arr[a] = arr[b];
  arr[b] = temp;
 }
 public static void main(String[] args)
 {
  int[] arr = {5,1,6,4,2,8,9};
  //排序前；
  printArray(arr);

  //排序
  //selectSort(arr);
  //bubbleSort(arr);

  //Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。
  //排序后：
  printArray(arr);
   
 }

 public static void printArray(int[] arr)
 {
  System.out.print("[");
  for(int x=0; x<arr.length; x++)
  {
   if(x!=arr.length-1)
    System.out.print(arr[x]+", ");
   else
    System.out.println(arr[x]+"]");

  }  
 }
}

折半查找：

首先要明确数组时有序的。

首先定义三个变量min、mid、max分来用来记录最小角标、中间角标、最大角标，中间角标的获取为(min+max)/2;获取中间角标之后，就可以获取中间角标对应的元素arr[mid];用我们所需要查找的key与中间角标运算进行比较，如果key>arr[mid];那么此时min的位置就是mid的下一个角标，min=mid+1;然后再次获取中间角标的元素，mid=(min+max)/2,同时也获取了中间角标对应的数组元素，arr[mid],然后同理，拿key与中间角标的元素进行比较.同样的原则，依次比较，直到key==arr[mid]的时候获取key.如果当出现了min>max或者时候则说明我们要查找的key在该数组中布存在，return-1；

实现代码：

class Test4
{
 public static void main(String[] args)
 {
  int[] arr = {3,2,1,5,4,2,9};
  int index = getIndex(arr,2);
  System.out.println("index="+index);

  int[] arr = {2,4,5,7,8,19,32,45};//8

  int index = getIndex_2(arr,190);
  System.out.println("index="+index);
  
  int x = Arrays.binarySearch(arr,190);//java提供好的一个进行折半查找的功能。开发时使用这个。
  System.out.println("x="+x);
  

 }

 public static int getIndex_2(int[] arr,int key)
 {
  int min = 0,max = arr.length-1,mid;

  while(min<=max)
  {
   mid = (max+min)>>1;

   if(key>arr[mid])
    min = mid + 1;
   else if(key<arr[mid])
    max = mid - 1;
   else
    return mid;
  }
  return min;
 }

 /*
 折半的第二种方式。
 */
 public static int halfSearch_2(int[] arr,int key)
 {
  int min = 0,max = arr.length-1,mid;

  while(min<=max)
  {
   mid = (max+min)>>1;

   if(key>arr[mid])
    min = mid + 1;
   else if(key<arr[mid])
    max = mid - 1;
   else
    return mid;
  }
  return -1;
 }
 /*
 折半查找。提高效率，但是必须要保证该数组是有序的数组。
 */
 public static int halfSearch(int[] arr,int key)
 {
  int min,max,mid;
  min = 0;
  max = arr.length-1;
  mid = (max+min)/2;

  while(arr[mid]!=key)
  {
   if(key>arr[mid])
    min = mid + 1;
   else if(key<arr[mid])
    max = mid - 1;

   if(min>max)
    return -1;
   mid = (max+min)/2;
  }
  return mid;
 }

 //定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。
 public static int getIndex(int[] arr,int key)
 {
  for(int x=0; x<arr.length; x++)
  {
   if(arr[x]==key)
    return x;
  }
  return -1;
 }
｝

 查表法

查表法思想：

1.什么时候使用查表法？

当元素很多，而且这些元素与数组有对应关系，而且这些数字都有角标的规律的时候。

扩展：什么时候使用数组？

当同一类型的元素较多时，就使用数组这个容器对数据进行存储。

2.查表法思想的代码体现：

0  1  2 3  4  5  6  7  8   9  10 11  12  13 14  15

'0', '1', '2',  '3','4','5',  '6',' 7',  '8', '9','A','  B',  'C' ,'D', 'E' ,'F'

我们发现十六进制中一共有16个元素，而且每通过&15获取的数字都再15之内，都有对应的十六进制元素，而且元素对应的数字正好有规律，而且符合了数组这种容器的特点角标，那么可以将十六进制的元素都存储到数组中，将每次&15的结果作为角标去查这个数组，就可以获取到十六进制的对应的元素。这就是查表思想。

代码实现：

Public static void searchList(int num)

{     //定义一个十六进制的元素表

Char[] arr={'0', '1', '2', '3', '4','5',  '6',' 7',  '8', '9','A','  B',  'C' ,'D', 'E' ,'F'};

//定义一个char类型元素的数组，用于存储每次获取到的十六进制值。

Char[] chs=new char[8];

Int pos=chs.length;

While(num!=0)

{

Int temp=num&15;

Chs[--pos]=arr[temp];

Num=num>>>4;

}

For(int x=pos;x<chs.length;x++)

{

//打印数组；

}

}

进制转换：

class Test7
{
 public static void main(String[] args)
 {
  toBin(-6);
  toHex(-60);
  toBa(60);

  System.out.println(Integer.toBinaryString(6));
  System.out.println(Integer.toHexString(6));
 }

/*
十进制-->二进制

*/
 public static void toBin(int num)
 {
  trans(num,1,1);
 }

 /*
 十进制-->八进制
 */
 public static void toBa(int num)
 {
  trans(num,7,3);
 }
 /*
 十进制-->十六进制
 */
 public static void toHex(int num)
 {
  trans(num,15,4);
 }

 public static void trans(int num,int base,int offset)
 {

  if(num==0)
  {
   System.out.println(0);
   return ;
  }
  char[] chs = {'0','1','2','3'
                ,'4','5','6','7'
                ,'8','9','A','B'
                ,'C','D','E','F'};
  char[] arr = new char[32];

  int pos = arr.length;

  while(num!=0)
  {
   int temp = num & base;
   arr[--pos] = chs[temp];
   num = num >>> offset;
  }

  for(int x=pos; x<arr.length; x++)
  {
   System.out.print(arr[x]);
  }

  return ;
 }
}

二维数组

格式1：int[] arr = new int [3][2];

          定义了名称为arr的二维数组

          二维数组中有3个一维数组

          每一个一维数组中有2个元素

          一维数组的名称分别为arr[0],arr[1],arr[2]

          给第一个一维数组1角标位赋值为56的写法是：arr[0][1]=56;

格式2：int [][] arr = new int[3][];

          二维数组中有3个一维数组

          每个一维数组都是默认初始化值NULL

          可以对这个三个一维数组分别进行初始化

           arr[0] = new int[3];

           arr[1] = new int[1];

           arr[2] = new int[2];

示例代码：

class 2Demo
{
 public static void main(String[] args)
 {
  int[] arr = new int[3];//一维数组。

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

  System.out.println(arr[0][1]); 
  int[][] arr  = new int[3][];

  arr[0] = new int[3];
  arr[1] = new int[1];
  arr[2] = new int[2];
  System.out.println(arr.length);//打印是二维数组的长度 3；
  System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度

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

  int sum = 0;
  for(int x=0; x<arr.length;x++)
  {
   for(int y=0; y<arr[x].length; y++)
   {
    sum = sum + arr[x][y];
   }
  }

  System.out.println("sum="+sum);
 }
}

 

 

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