黑马程序员_第4天

（一）   数组

静态初始化:

int[] arr = new int[2];//建议格式

int arr[] = new int[2];//也可以

 

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

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

 

int[] arr = new int[5];

arr[0] = 90;

arr[1] = 80;

boolean型数组默认值为false.

数组操作常见问题：

　　ArrayIndexOutOfBoundsException: 操作数组时，访问到了数组中不存在的角标。

　　NullPointerException:空指针异常。当引用没有任何指向值为null的情况，该引用还在用于操作实体。

数组常见操作-遍历

获取数组中的元素。通常会用的遍历。

数组中有一个属性可以直接获取到数组元素个数。length.

使用方式：数组名称.length

 

（二）   排序-选择排序、冒泡排序

选择排序特点：

内循环结束一次，最值出现在头角标位置上。

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;
}

 

Java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码:

Arrays.sort(arr);

 

（三）数组的查找操作

 //定义功能，获取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;
}

 

练习：有一个有序的数组，想要将一个元素插入到该数组中，

还要保证该数组是有序的。如何获取该元素在数组中的位置。

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 void toBin(int num)
{
    StringBuffer sb = new StringBuffer();
    while(num>0)
    {
        //System.out.println(num%2);
        sb.append(num%2);
        num = num / 2;
    }
    System.out.println(sb.reverse());
}

 

（五）十进制转十六进制

//十进制-->十六进制
public static void toHex(int num)
{
       StringBuffer sb = new StringBuffer();
       for(int x=0; x<8; x++)
       {
                int temp = num & 15;
                if(temp >9)
                {
                         //System.out.println((char)(temp-10 +'A'));
                         sb.append((char)(temp-10 +'A'));
                }
                else
                {
                         //System.out.println(temp);
                         sb.append(temp);
                }
                num = num >>> 4;
       }
       System.out.println(sb.reverse());
}

  

（六）十进制转十六进制（查表法）

0  1  2  3  4  5  6  7  8  9  A   B   C   D   E   F  十六进制中的元素。

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

查表法：将所有的元素临时存储起来。建立对应关系。

每一次&15后的值作为索引去查建立好的表。就可以找对应的元素。

这样比 -10+'a'简单的多。

这个表怎么建立呢？

可以通过数组的形式来定义。  

public static void toHex(int num)
{
    char[] chs = {'0','1','2','3'
               ,'4','5','6','7'
               ,'8','9','A','B'
               ,'C','D','E','F'};
    //定义一个临时容器。
    char[] arr = new char[8];
    int pos = arr.length;
    while(num!=0)
    {
        int temp = num & 15;
        //System.out.println(chs[temp]);
        arr[--pos] = chs[temp];
        num = num >>> 4;
    }
    System.out.println("pos="+pos);
    //存储数据的arr数组遍历。
    for(int x=pos;x<arr.length; x++)
    {
            System.out.print(arr[x]+",");
    }
}

 

（七）十进制转二进制（查表法）

public static void toBin_2(int num)
{
    char[] chs = {'0','1'};
    char[] arr = new char[32];
    int pos = arr.length;
    while(num!=0)
    {
        int temp = num & 1;
        arr[--pos] = chs[temp];
        num = num >>> 1;
    }
    for(int x=pos; x<arr.length;x++)
    {
        System.out.print(arr[x]);
    }
}

 

 

（八）进制转换优化

class ArrayTest7 
{
    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角标位赋值78写法是：arr[0][1] = 78;

格式2：

int[][] arr = new int[3][];

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

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

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

arr[0] = new int[3];

arr[1] = new int[1];

arr[2] = new int[2];

 

二维数组练习

定义一维数组：

int[] x; int x[];

定义二维数组：

int[][] y; int y[][]; int[] y[];

int[] x,y[];//x一维，y二维。

int[] x;

int[] y[];


a.
x[0] = y;//error

 

b.
y[0] = x;//yes

 

c.
y[0][0] = x;//error

 

d.
x[0][0] = y;//error

 

e.
y[0][0] = x[0];//yes

 

f.
x=y;//error