Java学习的第六天

/*

输出数组的第一次出现的最大值和最小值；

*/

public class array

{

   public static void main(String[] args)

   {

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

      int z=arraymax(array);

      int j=z+1;

      int k=arraymin(array);

      int m=k+1;

      System.out.println("max = "+array[j-1]+"\n"+"第"+j+"个数");

      System.out.println("min = "+array[m-1]+"\n"+"第"+m+"个数");

   }

   //得到最大值

   public static int arraymax(int[] array)

   {

      int max = array[0];

      int j=0;

      for(int i=1; i<array.length; i++)

      {

          if(max<array[i])

          {

             max = array[i];

             j = i;

          }

      }

      return j;

   }

   //得到最小值

   public static int arraymin(int[] array)

   {

      int min = array[0];

      int j = 0;

      for(int i = 1; i<array.length; i++)

      {

          if(min>array[i])

          {

             min = array[i];

             j = i;

          }

      }

      return j;

   }

}

注意：不能将最大最小值直接赋值0；比如，如果全是出现负数，0就是最大值，但0不存在于数组中；

/*

冒泡，讲数组排序，非递减

*/

public class array

{

   public static void main(String[] args)

   {

     int[] array1 = new int[]{9,8,7,6,5,4,3,2,1,0};

     getarray(array1);

     for(int i = 0;i<array1.length;i++)

     {

        System.out.println("array["+i+"]"+"="+array1[i]);

     }

   }

   //实现冒泡

   public static void getarray(int[] array)//void调用该函数，getarray(array1);实参是地址，操作形参相当于操作实参

   {

     int n = 0;

     for(int i = 1; i<array.length;i++)

     {   

        for(int j=0; j<array.length-i; j++)

        {

           if(array[j]>array[j+1])

           {

             n=array[j];

             array[j]=array[j+1];

             array[j+1]=n;

           }int min = array[0];

           /*if(min>array[j])

           {n = min;min=array[j];array[j]=n;}//这样只是n=9，一直循环，改变之后的数组，但没有改变之前的数组；

           */

/*引进max或者min进行循环是为了得到对应的最大最小值，只为得到一个结果

如果用在像冒泡这样的数组元素相互复值，不是得到一个结果，而是得到一个数组时，由于前面的值无法改变,会得到一组相同元素的数组；*/

        }

     }

   }

}

折半查找，可以提高效率，但必须保证数组是有序数组；

（先排序再折半查找范围，再折半……）

排序后

min = 0; max=array.length-1; mid=(min+max)/2;

如果大于array.[mid]则范围在array.[mid+1]到array.[max]

如果小于array.[mid]则范围在array.[min]到array.[mid-1]

以上两种情况以array[mid]=所需要值结束；（有两种情况，第一种当min!=max时相同，第二种当min=max时相同）

数组本来没有这个数就以min>max结束；

public class array

{

   public static void main(String[] args)

   {

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

     int i =Getmax(array,8);

     if(i>=0)

        System.out.println("第"+i+"个数");

     else

        System.out.println("不存在");

   }

   //第i个数相同，或者不存在

   public static int Getmax(int[] array,int e)

   {

     int min = 0;

     int max = array.length-1;

     int mid = (min + max)/2;

     while(min<=max)//不知道循环几次，以min>max结束

     {

        if(array[mid]<e)

        {

        min = mid + 1;

        mid = (min + max)/2;

        }

        if(array[mid]>e)

        {

        max = mid - 1;

        mid = (min + max)/2;

        }

        if(array[mid]==e)

        return mid+1;

     }

        return -1;//min>max;返回负数便于判断

   }

}

十进制转变为二进制

public class array

{

   public static void main(String[] args)

   {

     tobin(6);

   }

   public static void tobin(int num)

   {

     StringBuffer sb = new StringBuffer();

      while (num>0)

     {

        sb.append(num%2);

        num = num/2;

     }

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

   }

}

append英 [əˈpend]   美 [əˈpɛnd] 

vt.附加;添加;贴上;签（名）

reverse英 [rɪˈvɜ:s]   美 [rɪˈvɜ:rs] 

vt.& vi.（使）反转;（使）颠倒;掉换，交换;[法]撤消，推翻

vi.倒退;[桥牌]逆叫

adj.反面的;颠倒的;倒开的;[生]倒卷的

n.倒转，反向;[机]回动;倒退;失败

buffer英 [ˈbʌfə(r)]   美 [ˈbʌfɚ] 

n.缓冲器;起缓冲作用的人（或物）;[化]缓冲液，缓冲剂;[计]缓冲区

vt.缓冲;[化]把缓冲液加入（溶液）

十进制转化为十六进制

public class array

{

   public static void main(String[] args)

   {

     toHex(60);

   }

   public static void toHex(int num)

   {

     StringBuffer sb = new StringBuffer();

     while (num>0)

     {

        if(num%16>=10)//十六进制超过9的部分为字母，不能直接存入sb中，不然会显示两个字符，所以需要先强制转换成char类型对应的字母；

        {

           char b=(char)('A'-10+num%16); //强制转换

           sb.append(b);

        }

        else

           sb.append(num%16);

        num = num/16;

     }

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

   }

}

二维数组

把数组作为元素存在数组当中(数组存着另一个数组的地址)

System.out.println(array);------- [[I@2a33fae0

System.out.println(array[0]);------- [I@2a33fae0

System.out.println(array[0][0]);-------0

定义1 int[][] array = new int[2][3]

---定义了名称为array的二维数组，每一个一维数组中有四个元素

定义2 int[][] array = new int[3][]

array[0]=new int [3];

array[1]=new int [1];

array[2]=new int [2];

定义3 int[][] array = {{1,2,3},{2,4,5,6,0},{8,5,6}};

int[][] array = new int[3][]；

System.out.println(array[0]);-------null

数组默认初始化值为null

(数组array[0], array[1], array[2])

 若给于赋值

array[0]=new int [3];

array[1]=new int [1];

array[2]=new int [2];

System.out.println(array[0]);--- [[email protected]

System.out.println(array[0][0]);---0

此时为不规则数组

打印数组长度

int[][] array = new int[3][]；

System.out.println(arr.length);//打印是二维数组的长度 3；//一个大的二维数组里面存着三个一维数组

System.out.println(arr[1].length);//打印二维数组中第一个一维数组长度1;//每个一维数组又存着一维数组（的地址）

public class array

{

   public static void main(String[] args)

   {

     int sum=0;

     int[][] array = {{3,5,1,4},{2,1,4,},{1,1,1}};

     for(int i = 0;i<array.length;i++)

//二维数组所含一维数组的数量

     {

        for(int j = 0; j<array[i].length;j++)

//每个一维数组对于所含小一维数组元素的个数

        {

           sum +=array[i][j];

        }

     }

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

   }

}