黑马程序员：Java数组简介与数组的应用:选择排序、冒泡排序、折半查找

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------

何为数组：

同一种类型数据的集合，装数据的一个容器。

使用数组的好处：

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

数组的声明格式

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

  1 2	int [] arr =  new  int [ 5 ];  //定义一个长度为5，名称为arr的整数类型数组 int  arr[] =  new  int [ 5 ];  //这种类型意思和上面的一样，但不建议这样书写

  
  
• 格式2：元素类型[] 数组名 = new 元素类型[]{元素1,元素2,元素3...};

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

数组的长度及默认内存中的值介绍

int[] arr = new int[3]; //长度为3，内存中的值为000

System.out.println(arr[2]); //结果输出0

System.out.println(arr[3]); //超出数组范围。arr数组长度为3，共3个值：arr[0],arr[1],arr[2]; 故arr[3]超出数组范围，但编译时不会出错，执行时才出错。

如何获取数组长度

属性：length

用法：数组名称.length

例： arr[5]; arr.length的值为5

如何获取数组中的值

System.out.println(arr[0]); //获取数组中的第一个值

若输出语句写为 System.out.println(arr); //结果会输出类似[I@de6ced的结果

[表示一维数组，I表示int数组类型 @右边的十六进制值表示数组在内存中的地址。

二维数组小练习

int[] x,y[];  //其实就是int[] x; int[] y[]; 前面是一维数组，后面是二维数组 int[][] y; int y[][];

a. x[0]=y;  //错误，二维数组不能赋值给一维数组

b. y[0]=x;  //正确，一维数组可以赋值给y[0]这个一维数组

c. y[0][0]=x; //错误，x这个一维数组不能赋值给y[0][0]，它是一个具体元素

d. x[0][0]=y; //错误，x是一维数组

e. y[0][0]=x[0]; //正确 元素之间可以赋值。

数组的几个小应用

• 十进制转化为二进制、八进制、十六进制
  

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

  /* 1.需要转化的值num与目标进制基数base做与运算，即num & base 2.做完与运算后，向右移动二进制转化为目标进制的位数offset 3.循环以上动作，直到num&base的值为0，则停止。 4.将以上的值依次存入arr数组中，从右向左。 5.循环输出arr数组 */ class  TransDemo {      public  static  void  main(String[] args)      {          toBin( 60 );          hr();          toOctal( 60 );          hr();          toHex(- 60 );          hr();      }      public  static  void  hr()      {          System.out.println();  //换行      }      public  static  void  trans( int  num,  int  base,  int  offset)      {          char [] chs = { '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' };          char [] arr =  new  char [ 32 ];  //最大长度为二进制中的32位          int  pos = arr.length;          if  (num ==  0 )              System.out.println( 0 );          while  (num !=  0 )          {              int  temp = num & base;              arr[--pos] = chs[temp];  //倒序存储数据              num = num >>> offset;          }          for  ( int  x=pos; x<arr.length; x++)          {              //x=pos，从第一有效位开始取值              System.out.print(arr[x]);          }      }      //num进行二进制转化      public  static  void  toBin( int  num)      {          trans(num, 1 , 1 );      }      //num进行八进制转化      public  static  void  toOctal( int  num)      {          trans(num, 7 , 3 );      }      //num进行十六进制转化      public  static  void  toHex( int  num)      {          trans(num, 15 , 4 );      } }

  
  
• 对数组进行排序：选择排序、冒泡排序两种方式
  

  class SortDemo
  {
      public static void main(String[] args)
      {
          int[] arr1 = {3,4,5,9,1,2,8};
          int[] arr2 = {13,14,15,19,11,12,18};
          selectSort(arr1);
          printArray(arr1);
          bubbleSort(arr2);
          printArray(arr2);
      }
  	//换行
  	public static void hr()
  	{
  		System.out.println();
  	}
  
  	//数值互换方法
  	public static void swap(int[] arr, int a, int b)
  	{
  		int temp = arr[a];
  		arr[a] = arr[b];
  		arr[b] = temp;
  	}
  
  	//选择排序方法
  	public static void selectSort(int[] arr)
  	{
  		for (int x=0; x<arr.length-1; x++)
  		{
  			for (int y=x+1; y<arr.length-1; y++)
  			{
  				if (arr[x] > arr[y])
  				{
  					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++)
  			{
  				if (arr[y] > arr[y+1])
  				{
  					swap(arr,y,y+1);
  				}
  
  			}
  		}
  	}
  
  	//打印数组
  	public static void printArray(int[] arr)
  	{
  		for (int x=0; x<arr.length; x++)
  		{
  			if (x != arr.length-1)
  			{
  				System.out.print(arr[x]+", ");
  			}
  			else
  				System.out.println(arr[x]);
  		}
  	}
  }

  
  
  
• 折半查找的两中方式
  

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

  /* 折半查找的前提是查找中的数值是有序排列的 第一种方式：当折半的值mid不等于查找值key的时候，循环折半，直到循环结束返回查找数组arr中的角标值，若最小值大于最大值时，返回-1，代表key不存在于arr中 第二中方式：当最小值小于等于最大值时，循环折半，当key=mid时，返回角标值，循环结束还没return则return -1代表arr中不存在key； */ class  FindDemo {      public  static  void  main(String[] args)      {          int [] arr = { 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 };          int  x = halfFind(arr, 3 );          int  y = halfFind2(arr, 10 );          System.out.println(x);          System.out.println(y);      }      //第一种折半查找方式      public  static  int  halfFind( int [] arr,  int  key)      {          int  min= 0 , max=arr.length- 1 ,mid=(min+max)>> 1 ;          while  (arr[mid] != key)          {              if (key > arr[mid])              {                  min = mid +  1 ;              }              else  if  (key < arr[mid])              {                  max = mid -  1 ;              }              mid = (min+max)>> 1 ;              if (min > max)                  return  - 1 ;          }          return  mid;      }      //第二种折半查找方式      public  static  int  halfFind2( int [] arr,  int  key)      {          int  min= 0 , max=arr.length- 1 ,mid;          while  (min <= max)          {              mid = (min+max)>> 1 ;              if (key > arr[mid])                  min = mid +  1 ;              else  if (key < arr[mid])                  max = mid -  1 ;              else                  return  mid;          }          return  - 1 ;      } }

最后

以上就是爱撒娇大叔最近收集整理的关于黑马程序员：Java数组简介与数组的应用:选择排序、冒泡排序、折半查找的全部内容，更多相关黑马程序员：Java数组简介与数组内容请搜索靠谱客的其他文章。