数组 (6.6)

 1、数组就是一个箱子：箱子里有格子 （角标）

int[] s = new int[3];

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

2.内存的划分：（内存与变量的范围的关系 ）

1.寄存器 cpu
2.本地方法区
3.方法区
4.栈内存（随时释放）
存储的都是局部变量
而且变量所属的作用域一旦结束，该变量就自动释放。
5.堆内存
存储是数组和对象（其实数组就是对象）凡是new建立都在堆中。
特点：
1.每一个实体都有实地址值
2.堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同
整数是：0
小数:0.0或者0.0f
boolean: false
char: '\u0000'

3.垃圾回收机制

new 开辟空间运算符
6.存储已知的具体数据
int[] arr = {89, 34, 270, 17};

4.遍历

for(int x =0; i<arr.length; x++){
System.out.println(arr[x]);
}

5.最值

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

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

6.排序

a.选择排序

public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length; 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;
}
}
}
}

数组进行反转。

public static void reverseArray(int[] arr)
    {
        for(int start=0,end=arr.length-1; start<end ; start++,end--)
        {
            /*
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            */
            swap(arr,start,end);
        }
    }
    public static void swap(int[] arr,int a,int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

b.冒泡排序

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

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

折半查找

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

/*
    折半查找。提高效率，但是必须要保证该数组是有序的数组。
    */
    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;
    }

/*
    折半的第二种方式。
    */
    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;
    }

 进制转换

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

/*
    十进制-->十六进制
    */
    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 ;
    }