20160714 数组

class  笔记5
{
	public static void main(String[] args)                       
	/*
	    数组定义:同一种类型数据的集合;
		好处:可以自动给数组中的元素从0编号,方便操作这些元素;
		格式一:元素类型 [] 数组名=new 元素类型 [元素个数或数组长度];
		         int    []  array=new    int      [5];
		格式二:元素类型 [] 数组名=new 元素类型 [] {};
		       int      []  array1=new int     [] {1,2,3,4,5};
			   int      []  array2={1,2,3,4};

	*/	



	/*{                                                    //数组的定义
		int [] array=new int [5];                        //格式1:
		System.out.println(array.length); 

		int [] array1=new int []{1,2,3,4,5};             //格式2:
		System.out.println(array1.length);

		int [] array2={1,2,3,4};
		System.out.println(array2.length);

        double [] douArray={1,2,3,4,5,6};
		System.out.println(douArray.length);

		double [] douArray1=new double []{4,5,6};
		System.out.println(douArray1.length);

		String [] strArray=new String [10];
		String [] strArray1={"123","432","345"};
		System.out.println(strArray1.length);
}
*/

/*
       int [] iArray=new int [] {1,2,3,4,5};          //数组内容提取
	   int i= iArray[2];
	   System.out.println(i);

      String [] strArray=new String[]{"111","222"};
	  String s=strArray[1];
	  System.out.println(s);
*/

	  /*
	    java虚拟机内存结构划分:
		程序计数器(program Counter Resister),堆(Heap),栈(Stack),本地栈(Native Stack),方法区(Method Area)

		栈内存到堆内存:存放的是堆内存的地址    扩展!!!
	  */
   //   System.out.println(strArray);    //输出结果:[Ljava.lang.String;@1db9742
     
  //    int [] array3=new int[3];          //默认初始值
//	  System.out.println(array3[0]);      //输出结果:0

     // int [] array4=new int[3];
	//  System.out.println(array4[3]);     //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3   "输出角标越界"

   /*   int [] array5=new int[3]; 
	  array5[0]=123;
	  array5[1]=23;
	  array5[2]=3;
	  System.out.println(array5[0]); 
*/
	 // int [] array6=null;               //空指针异常      Exception in thread "main" java.lang.NullPointerException
	  //System.out.println(array6[1]);

     /*
	 int [] array7=null;  
	  if(array7!=null){
	  System.out.println(array7[1]);
	  }else{
	  System.out.println("is null");
	  }
	  if(array7==null){
	  System.out.println("is not null");
	  }
*/

	
{    // printArray();                               //只能某一个单独执行

		   addValue();
		}
/*    public static void printArray()
{    
	int[] array=new int []{1,2,3,4,5,6,7,8};
	for(int i=0;i<array.length;i++){
		if(i<5)
	System.out.println(array[i]);
	}
	
}
*/


	public static void addValue(){
	int [] array=new int [5];
	for(int i=0;i<array.length;i++)
	{
	array[i]=2*i+1;
	System.out.print("*");
	}
	
	for(int j=0;j<array.length;j++)
		{
	  System.out.print(array[j]);        //复制循环执行完毕,再执行输出循环
	}                                    //输出结果:*****13579

	}
	
}

***************************************************************************************

<pre name="code" class="java">/**
   判断数组内的最大,最小值  

*/
class 笔记501 
{
	
	public static void main(String[] args)                 //数组常见操作
	{
		int [] array={ 1,3,5,6,10,12,18,19};                          
		int maxValue=getMaxValue(array);                   //Max
		System.out.println(maxValue);

        int minValue=getMinValue(array);                   //Min
		System.out.println(minValue);

		 sortAsc(array);

		 for(int i=0;i<array.length;i++)                  //冒泡排序
			 {
			 System.out.print(array[i]+",");
		     }
 System.out.println();
 System.out.println("*****************");                //分隔

	     sortAsc1(array);
		 
		 for(int i=0;i<array.length;i++)                  //选择排序
			 {
			 System.out.print(array[i]+",");
		     }
   System.out.println();                                   //分隔
   System.out.println("***********************");

  int index=binarySearch(array,0,array.length,20);          //二分查找
  System.out.println(index);


	}


            //列最大值
public static int getMaxValue(int[]array){
	int tmp=-1;
	if(array!=null) {                                      //判断空指针
		int tmpValue=array[0];
	   for (int i=0;i<array.length ;i++ )          //为何i=0也可输出最大值,都一样
	   {  if(array[i]>tmpValue)       //进行两个值的比较,将大的值保留下来进行下一轮的比较
           tmpValue=array[i];
	   }
	   tmp=tmpValue;
	}                                         


	return tmp;
	}
                
				
				//列最小值
	public static int getMinValue(int [] array){
	int tmp=-1;
    if(array!=null)
		{
		int tmpValue=array[0];
		for (int i=0;i<array.length ;i++ )         //5,8,2,6,9
		{
			if(array[i]<tmpValue)                  //内部循环完赋值
            tmpValue=array[i];
		}
		   tmp=tmpValue;
	    }

	return tmp;
	}
	

	/*
	冒泡排序
	    从小到大的排序
	*/
    public static void sortAsc(int[] array)
   {
	if(array!=null)
	  {
	    for(int i=0;i<array.length;i++)
			{
			for(int j=0;j<array.length-1-i;j++)
				{
				if(array[j]>array[j+1])
					{
					int tmp;
					tmp=array[j];
					array[j]=array[j+1];
					array[j+1]=tmp;
				    }
			    }
		    }
	  }
	
	
	}

   /*
   选择排序    
   
   第一个逐渐对比到尾部


   */
    public static void sortAsc1(int[]array)
		{
		if(array!=null)
			{
			 for(int i=0;i<array.length;i++)
				 {
				 for(int j=i+1;j<array.length;j++)
					 {
					 if(array[i]>array[j])
						 {
						 int tmp;
						 tmp=array[i];
						 array[i]=array[j];
						 array[j]=tmp;
					     }
				     }
			     }
		    }
	    }
 /*
 递归排序

 */









 /*
 二分查找:  只适合于排序好的数列

 1,3,5,6,10,12,18,19
 目标:快速找到12所在的位置

 1,3,5,6  10  12,18,19
 第一次查找
10-12
10,12,18,19

12-12
这个数的脚标就是所需要查找的数字
 */
  public static int binarySearch(int[]array,int beginIndex,int endIndex,int findValue)
	                            //     数组        0          数组长度        18
	  {
	  if(array!=null)
		  {
           int middleIndex=(beginIndex+endIndex)/2;     //middleIndex=4;               6
		   int middleValue=array[middleIndex];         //middleValue=array[4]=10;     array[6]=18;
		   if(middleValue==findValue)                   //                            18==18;
			   {
			   return middleIndex;                     //                            return 6;(最终结果)
		       }
			   else if(middleValue<findValue)      //10<18                            //递归,自己调用自己
				   {
				   return binarySearch(array,middleIndex,endIndex,findValue);
				                     //         4          8        18
			       }
				   else if(middleValue>findValue)
					   {
                        return binarySearch(array,beginIndex,middleIndex,findValue);
				       }
					   else
						   {
						   return -1;                              //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 8
					       }                                       // 例外;异议    通过                             越       界
	      }     
		  else
			  {
		      return -1;
			  }
      }



}

**********************************************************************************

<pre name="code" class="java">/**
  数组查找:(基本查找)
  需求:查询出数组中元素是5的脚标,只返回第一个元素的脚标
  结果:1.找到了 返回脚标
       2.找不到 返回-1


	   二分查找:每次查找都是从数组的中间开始查找,数据效率提高两倍
	            前提条件:数组本身要保证有序的
*/

class  笔记502
{
	public static void main(String[] args) 
	{
		System.out.println("输出脚标:"+getIndex(9));


		int[][]array=new int[3][2];          //二维数组

		System.out.println(array);          //输出内存地址
		System.out.println(array[0]);       //输出内存地址
		System.out.println(array[0][0]);       //默认 0


       //二维数组的遍历:
	   for (int y=0;y<array.length ;y++ )
	   {
		   for(int x=0;x<array[y].length;x++)
			   {
			   System.out.println(array[y][x]);
		       }
	   }
      

     int[][]array=new int[3][];
	 array[0]=new int[1];
	 array[1]=new int[2];
	 array[2]=new int[3];
	 //如何给二维数组赋值
	 array
    

    int[][]array={{1,2,3},{11,22},{110}};
	for (int x=0;x<array ; )
	{
	}

	}

	/*
	public static int getIndex(int num)                 //数组查找             //两个输出口
		{
		//定于数组
		int[]array=new int[] {2,3,6,5,7,8};

		for (int index=0;index<array.length ;index++ )
		    {
			if(array[index]==num)
				{
				return index;
			    }
		    }
			return -1;
	    }
*/
       public static int getIndex(int num)                                  //只有一个输出口
		{
		   int i=-1;
		//定于数组
		int[]array=new int[] {2,3,6,5,7,8};

		for (int index=0;index<array.length ;index++ )
		    {
			if(array[index]==num)
				{
			     i= index;
				 break;                                 //没有break,有重复数字,输出最后的数字的脚标
			    }
		    }
			return i;                                   //退出当前循环,直接return值
	    }

     /*
	 二维数组
	 格式1:int[][]array=new int[3][2];

	 格式2:int[][]array=new int[3][];
	 array[0]=new int[1];
	 array[1]=new int[2];
	 array[2]=new int[3];

	 格式3:int[][]array={{1,2,3},{11,22},{110}};


	 二维数组的遍历:

	 
	 */



}

******************************************************************************

<pre name="code" class="java">/**
进制转换
十进制转换成16进制
*/
class  HexDemon
{
	public static void main(String[] args) 
	{
		


		/*
		int num=60;//3c
		
		while(num>0)
			{
		     int tem=num & 15;
			 if (tem>9)
			 {
				 //转换成A--F
				 System.out.println((char)((tem-10)+'A'));
			 }
			 else
				 {
				 System.out.println(tem);
			     }

				 num=num>>>4;
			}
	*/


           toHex(60);

		  // toHex1(50);
	}   

	    //十进制转换为16进制
	    //发现一个问题:反过来输出
		//解决思路:使用数组存起来,最后将数组倒序输出
		//什么数组?字符数组
		//4字节  32位
		//0000 0000 0000 0000 0000 0000 0000 0000
    public static void toHex(int num)
		{
		char[]c=new char[8];//在内存中开辟一个空间储存了八个字符的数组对象
		int index=0;
		while (num>0)
		     {
			  int tem=num&15;
			  if(tem>9)
				  {
				  //A-F
				  c[index]=(char)((tem-10)+'A');
			      }
				  else
					  {
					  //0-9  转换成字符0-9
					  c[index]=(char)(tem+'0');
				      }
					  index++;
					  num=num>>>4;
		     }
			 //将数组倒序打印
			 for (int i=index-1;i>=0;i-- )
			 {
				 System.out.println(c[i]);
			 }
	    }
/*
0,1,2,3,4,5,6,7,8,9,11,12,13,14,15



思路:率先定义好16进制的字符数组,位与15后


*/
   /*    public static void toHex1(int num)
		{
		char[]c=new char[8];
		int index=0;
		while (num>0)
		     {
			  int tem=num&15;
			  if(tem>9)
				  {
				  //A-F
				  c[index]=(char)((tem-10)+'A');
			      }
				  else
					  {
					  //0-9  转换成字符0-9
					  c[index]=(char)(tem+'0');
				      }
					  index++;
					  num=num>>>4;
		     }
			 //将数组倒序打印
			 for (int i=index-1;i>=0;i-- )
			 {
				 System.out.println(c[i]);
			 }
	    }
*/

}

***********************************************************************************

/**
数据加密
某个公司采用公用电话传递数据信息,数据是小于8位的整数,为了确保安全,在传递过程中需要加密,加密规则如下:
首先将数据倒序,然后将每位数字都加上5,再用和除以10的余数代替该数字,然后将第一位和最后一位数字交换.
请任意给定一个小于8位的整数,然后,把加密后的结果在控制台打印出来

例:123456

输出:654321
     109876
	 609871


*/
class codetran 
{
	public static void main(String[] args) 
	{
		

		tranCode(123456);
	}

	public static void tranCode(int num)
		{
        
		String aS = String.valueOf(num);//将基本数据型态转换成 String 的 static 方法 
        char[] asC = aS.toCharArray();//ToCharArray 将字符串转换为字符数组
        int[]c=new int[8];
		int index=0;
        for(int i=0;i<asC.length;i++)
			{
 
        System.out.println(asC[i]);
		index++;
		    }
          System.out.println("************");
          for (int i=index-1;i>=0;i-- )
			   {
			    
			  	 System.out.print(asC[i]+" ");
				 //System.out.print(index+" ");
               }
 System.out.println();
 System.out.println("************");
              //以上部分完成数据倒序
           for(int i=index-1;i>=0;i--)
			{
			      c[i]=(asC[i]-48+5)%10;

			    


			System.out.print(c[i]+" ");
			   }
			  int ex;
			  ex=c[0];
			  c[0]=c[index-1];
			  c[index-1]=ex;

 System.out.println();
 System.out.println("************");

         for(int i=index-1;i>=0;i--)
			{
			   
			     

			System.out.print(c[i]+" ");
			   }


	     

          
	    }
}