基础学习day04---数组的操作

一、数组基本常见操作

1.1、静态初始化

//第一种声明

             //第一种声明
             int [] arr=new int[5];
        //第二种声明
        int [] arr1=new int[]{5,3,8,1,9,11};
        //或者
        int [] arr2={5,3,8,1,9,11};

1.2、常见问题

下标越界

//声明数组
        int [] array=new int[3];
        System.out.println(array[3]);  //最在元素下标为2，发生异常 数组下标越界

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

空指针

//声明数组
        int [] array=new int[3];
        array=null;  //将数组设置为null
        System.out.println(array[1]);  //数组为空，发生空指针异常
Exception in thread "main" java.lang.NullPointerException

1.3、遍历

package com.day04;
/**
 * 数组的遍历
 * @author Administrator
 *
 */
public class ArrayDemo1 {

    public static void main(String[] args) {
        //声明数组
        int [] array={5,8,1,2,6};
        //遍历
        for(int i=0;i<array.length;i++){
            System.out.println("array["+i+"]="+array[i]);
        }

    }

}

结果：

array[0]=5
array[1]=8
array[2]=1
array[3]=2
array[4]=6

1.4、获取数组元素的值

package com.pb.demo1;

import java.util.Scanner;

/*
 * 输入5个学生的成绩，并求出最高分，最低分，平均分
 */
public class Demo5 {

    public static void main(String[] args) {
        //声明一个扫描器类似的变量
        Scanner input = new Scanner(System.in);
        //声明整形数组
        int [] scores=new int [5];
        System.out.println("请输入5个学生的成绩：成绩为整数");
        //为数组赋值
        for (int i = 0; i < scores.length; i++) {
            scores[i]=input.nextInt();
        }
        //总成绩
        float sum=0;
        //最低分
        int min=0;
        //最高分
        int max=0;
        //平均分
        float avg=0;
        //将第一个值赋为min和max，进行比较
        min=scores[0];
        max=scores[0];
        for (int i = 0; i < scores.length; i++) {
          //总成绩
            sum=sum+scores[i];
            //最低分
            if(scores[i] < min){
                min=scores[i];
            }
            //最高分
            if(scores[i]>max){
                max=scores[i];
            }

        }
        System.out.println("总成绩:"+sum);
        System.out.println("最低分:"+min);
        System.out.println("最高低:"+max);
        System.out.println("平均分:"+sum/scores.length);

    }

}

另一种 :用于打印数组中的元素，元素间用逗号隔开

package com.day04;
/**
 * 定义功能，用于打印数组中的元素，元素间用逗号隔开
 * @author Denny
 *
 */
public class ArrayDemo2 {

    public static void main(String[] args) {
        //声明数组
        int [] arr={3,6,8,1,9,2,68,98,83};
        printArray(arr);
    }
    //定义方法实现用于打印数组中的元素，元素间用逗号隔开
    public static void printArray(int [] arr){

        for(int x=0;x<arr.length;x++){
            if(x==0){
                System.out.print("{"+arr[x]+",");

            }else if(x==arr.length-1){
                System.out.print(arr[x]+"}");
            }else{
                System.out.print(arr[x]+",");
            }

        }
    }
}

结果：

{3,6,8,1,9,2,68,98,83}

二、排序

2.1、冒泡排序

package com.day04;

/**
 * 冒泡排序
 *
 * @author Denny
 *
 */
public class ArrayDemo4 {

    public static void main(String[] args) {
        int[] arr = { 5, 3, 1, 8, 4, 9, 11, 7 };
        System.out.println("=======排序前======");
        printArray(arr);

        System.out.println("\n=======排序后======");
        bubbleSorte(arr); // 排序
        printArray(arr);

    }

    // 冒泡排序
    public static void bubbleSorte(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]) { // 交换
                    int tmp = arr[y];
                    arr[y] = arr[y + 1];
                    arr[y + 1] = tmp;
                }
            }

        }

    }

    // 遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                System.out.print(arr[i] + ",");
            } else {
                System.out.print(arr[i] + "]");
            }
        }
    }

}

结果：

=======排序前======
[5,3,1,8,4,9,11,7]
=======排序后======
[1,3,4,5,7,8,9,11]

2.2、选择排序

package com.day04;

/**
 * 选择排序
 *
 * @author Denny
 *
 */
public class ArrayDemo5 {

    public static void main(String[] args) {

        int[] arr = { 5, 3, 1, 8, 4, 9, 11 ,7};
        System.out.println("=======排序前======");
        printArray(arr);

        System.out.println("\n=======排序后======");
        selectSort(arr);  //排序
        printArray(arr);
    }

    // 选择排序
    public static void selectSort(int[] arry) {
        for (int i = 0; i < arry.length - 1; i++) {

            for (int j = i + 1; j < arry.length; j++) {
                // 1和2比
                if (arry[i] > arry[j]) {
                    // 交换
                    int tmp = arry[i];
                    arry[i] = arry[j];
                    arry[j] = tmp;
                }
            }

        }

    }

    // 遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i!=arr.length-1){
            System.out.print(arr[i] + ",");
            }else{
                System.out.print(arr[i] + "]");
            }
        }
    }

}

结果：

=======排序前======
[5,3,1,8,4,9,11,7]
=======排序后======
[1,3,4,5,7,8,9,11]

2.3、二分法排序

package com.day04;

import java.util.Arrays;

/**
 * 二分法查找
 * @author Denny
 *
 */
public class ArrayDemo6 {

    public static void main(String[] args) {
        int[] arr = { 1,3,4,5,7,8,9,11};
      //int index=getIndex(arr,11);
        //使用Arrays.sort排序
        Arrays.sort(arr);
        //1,3,4,5,7,8,9,11
        //二分法查找
        //int index=halftSearch(arr,33);
        int index=halftSearch_2(arr,9);
      System.out.println("查找的index="+index);

    }
    //二分法查找，前题，要排序过的数组
    //先排序
    public static int halftSearch(int [] arr,int key){
        //最小下标
        int min=0;
        //最大下标
        int max=arr.length-1;
        //中间下标
        int mid=(min+max)/2;
        //循环
        while(arr[mid]!=key){

            if(key>arr[mid]){
                min=mid+1;
            }else if(key<arr[mid]){
                max=mid-1;
            }
            //重新计算中间值下标
            mid=(min+max)/2;
            if(min>max){
                return -1;
            }
        }
        return mid;
    }
    //二分法查找，前题，要排序过的数组第二种写法
    public static int halftSearch_2(int [] arr,int key){
        //最小下标
        int min=0;
        //最大下标
        int max=arr.length-1;
        //中间下标
        int 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;

    }

    //遍历查找
    public static int getIndex(int[] arr,int key){
        int index=-1;  //定义-1下标
        for (int i = 0; i < arr.length; i++) {
            if(key==arr[i]){
                index=i;
            }
        }

        return index;//返回下标变量

    }

}

2.4、示例

package com.day04;

/**
 * 有一个有序的数组，想要将一个元素插入到这个数组中， 还要保证这个数组是有序的
 *
 * @author Denny 1.二分法查找到下标
 *
 */
public class ArrayDemo7 {

    public static void main(String[] args) {
        int arr[] = { 2, 4, 5, 7, 19, 32, 45 };
        int index=getIndex(arr,35);
        System.out.println("index="+index);
    }
    //二分法查找，返回能插入的下标
    public static int getIndex(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 min;
    }

}

三、进制

3.1、十进制-二进制和十六进制

package com.day04;

public class ArrayTest1 {

    public static void main(String[] args) {

        toBin(6);
        toHex(60);
    }

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

    /*
     * 十进制转换为二进制
     */
    public static void toBin(int num) {
        StringBuffer sb = new StringBuffer();
        while (num > 0) {
            // System.out.println(num % 2);
            sb.append(num % 2);
            num /= 2;
        }
        System.out.println(sb.reverse());
    }
}

3.2、查表法

package com.day04;

public class ArrayTest2 {

    public static void main(String[] args) {
        toHex(60);
    }

    /*
     * 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'简单 这个表怎么建立？ 可以通过数组的形式来定义 结果是反着的，想要正过来可以通过StringBuffer reerse功能
     * 可以使用数组来完成
     */
    public static void toHex(int num) {
        // 十六进制数组
        char[] ch = { '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 tmp = num & 15;
            // System.out.println(ch[tmp]);
            arr[--pos] = ch[tmp];
            num = num >>> 4;
        }
        System.out.println("post="+pos);
        // 遍历输出
        for (int i = pos; i <arr.length; i++) {

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

查表法十进制转二进制

package com.day04;
/**
 * 十进制 转2进制
 * @author Administrator
 *
 */
public class ArrayTest3 {

    public static void main(String[] args) {
        toBin(-6);

    }
    /*
     *  十进制 转2进制
     */
    public static void toBin(int num){
        char [] ch={'0','1'}; //要查的表
        //存储数组
        char[] bin=new char[32];
        //下标指针
        int pos=bin.length;
        while(num!=0){
            int tmp=num&1;
            bin[--pos]=ch[tmp];
            num=num>>>1;
        }

        //输出
        for (int i = pos; i < bin.length; i++) {
            System.out.print(bin[i]);
        }
    }

}

最终完成

package com.day04;

/**
 * 转换
 *
 * @author Denny
 *
 */
public class ArrayTest4 {

    public static void main(String[] args) {

        //toBin(-6);
        toOtc(60);
        //toHex(-60);
    }
    /*
     * 十进制---》二进制
     */
    public static void toBin(int num){
        toTrans(num,1,1);
    }

    /*
     * 十进制---》八进制
     */
    public static void toOtc(int num){
        toTrans(num,7,3);
    }
    /*
     * 十进制---》十六进制
     */
    public static void toHex(int num){
        toTrans(num,15,4);
    }
    /*
     * 提供公有的转换方法 num 要转换的数 base与上的数如15，1，7， offset 移动的倍数
     */
    public static void toTrans(int num, int base, int offset) {

        if(num==0){
            System.out.println(num);
            return;
        }

        // 十六进制数组
        char[] ch = { '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 tmp = num & base;// 取
            arr[--pos] = ch[tmp]; // 查表取相对应的字符
            num = num >>> offset; // 右移

        }
        //遍历输出
        for (int i = pos; i < arr.length; i++) {
            System.out.print(arr[i]);
        }

    }

}

四、二维数组

4.1、二维数组定义

格式一：

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

定义名称为arr的二维数组

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

每个一维数组中有2个元素

一维数组名称分另为arr[0],arr[1],arr[2]

给第一个一维数组1下标标赋值78写法arr[0][1]=78;

格式二：

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

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

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

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

arr[0]=new int [3]

arr[1]=new int [1]

arr[2]=new int [2]

4.2、练习和常用操作

遍历

package com.day04;
/**
 * 二维数组常用操作
 * @author Denny
 *
 */
public class ArrayTest5 {

    public static void main(String[] args) {
        int [] [] arr={{3,5,7,8,1},{2,1,6},{5,7,9}};
        //遍历
        printArr(arr);
    }

    /*
     * 二维数组遍历
     */
    public static void printArr(int [] [] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }

}