java之数组小知识

数组

数组练习

1.根据索引找元素

需求 封装一个函数 传入数字1 返回 星期一…

public  static char chabiao(int a) {        char b[]=new char[]{'一','二','三','四','五','六','七'};        return b[a-1]；    }     public static void main(String[] args) {        char a=chabiao(2);        System.out.println(a);    }

2.根据元素找索引

//如果数组 长度为0//定义一个待返回值的函数 ，函数出口得有返回值。//数组长度为0 是不会循环的。// 防御试编程public static int chazhao1(int[] array,int a) {        int index=-1;//定义一个索引 为了返回值        //如果 索引初值为0 当数组长度为0时        //会返回0 这样会与数组下标真正为0时，混淆        //所以设索引初值为-1        for(int i=0;i<array.length;i++) {            if(a==array[i]) {                index=i;//保存查找出来的下标                //找到索引后立即停止循环                break;            }        }        return index;}

数组元素反转

反转(把数组中的元素位置 进行改变)

如何交换两个数

看例子

        int a=6;        int b=7;        int temp=0;        temp=0;        a=b;        b=temp;        System.out.println("a="+a+"b="+b);

数组元素交换的例子

 int[] array=new int[] {1,2,3,4,5,6};     // num表示交换的次数            int num = array.length/2;            for (int i = 0; i < num; i++) {                /*                 * array[0]和array[array.length-1-0]交换                 * array[1]和 array[array.length-1-1]                 * array[2]和 array[array.length-1-2]                 *                  * array[i]和 array[array.length-1-i]交换                 *                  */                temp=array[i];                array[i]=array[array.length-i-1];                array[array.length-i-1]=temp;            }          System.out.println(Arrays.toString(array))

顺带一提

将 值交换封装成函数

在调用次函数时 相当于 值的传递
这样交换了(空间不同 没有关系)

而 将数组元素交换封装成函数时
却可以

因为 在调用的时候 相当于 传的是地址

函数调用时 元素在地址间交换 地址还是原来的地址。

图示

数组的排序

系统排序法

直接调用系统写好的Arrays类中 方法 sort

public static void main(String[] args) {        // TODO Auto-generated method stub        int[] array = new int[] {5,3,2,11,33,22};        // 该方法没有返回值 实际上这个方法操作的是原数组        Arrays.sort(array);        System.out.println(Arrays.toString(array));    }

冒泡排序

数组的排序(开发中 不用自己写的)
1.冒泡排序

数组的排序(开发中 不用自己写的) 1.冒泡排序  核心:相邻两个数比较 大小 交换位置  分析 ：  原数 3 2 5 1  第一趟     2 3 5 1  2 3 5 1   array.length -1 -0  2 3 1 5  确定一个数(把最大值放在最后面)   第二趟：  2 3 1 5   array.length -1 -1  2 1 3 5 又确定 一个数   第三趟     array.length -1 -2    ->  array.length -1 -i  1 2 3 5 又确定 一个数  看图  ![这里写图片描述](http://img.blog.csdn.net/20171201203132807?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZHN6eTE4/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)  举例

// 封装一个函数 进行封装排序public static void sort(int[] sb) {    int temp=0;    for (int i = 0; i < sb.length-1; i++) {        for (int j = 0; j < sb.length-1-i; j++) {            // 交换位置 相邻两个数比较            if(sb[j]>sb[j+1])            {            temp=sb[j];            sb[j]=sb[j+1];            sb[j+1]=temp;            }        }    }}    public static void main(String[] args) {        // TODO Auto-generated method stub          int[] sb=new int[] {3,2,5,1};          //存入的数组相当于 把数组的首地址传过去了          // 注意：这里是地址的传递          // 拿到地址 就可以随便更改 元素的值          // 这是 sort函数 中 就是对原数组进行的操作          int temp=0;          //先将架构 搭起来          // 外层循环 控制比较的趟数          // 内循环-1避免数组越界;          // 内循环-i: 一趟比较确定一个数 就意味着 下次比较可以少比一次          for (int i = 0; i < sb.length-1; i++) {            for (int j = 0; j < sb.length-1-i; j++) {                // 交换位置 相邻两个数比较                if(sb[j]>sb[j+1])                {                temp=sb[j];                sb[j]=sb[j+1];                sb[j+1]=temp;                }            }        }          System.out.println(Arrays.toString(sb));    }

选择排序法

核心 选择一个位置数与下一个数进行比较

用这个位置数 和 数组中的每个数进行比较

一般 来说 就选第一个数 交换位置

看图

例子

public static void main(String[] args) {        // TODO Auto-generated method stub        int [] sb=new int[] {3,5,2,1,0};        // 外循环-1 ；最后一个数不用比较        // 内循环 j 的初始值要从1开始         // 因为 array[0]和array[0]不用比较        // 内循环+:也就是说每次都可以少比一个数        int temp=0;        for (int i = 0; i < sb.length-1; i++) {            for (int j = 1+i; j < sb.length; j++) {                /*                 * 分析 :谁和谁进行交换                 * array[j]和array[i]进行比较 且进行换位                 */                if(sb[i]>sb[j]) {                    temp=sb[i];                    sb[i]=sb[j];                    sb[j]=temp;                }            }        }        System.out.println(Arrays.toString(sb));

折半查找(不需要你掌握)

前提：需要一个有序数组

举例
public static void main(String[] args) {

    // TODO Auto-generated method stub    int [] sb=new int[] {2,4,6,8,10,12,14};    int a=10;    int min=0;    int max=sb.length;    int mid=(max+min)/2;    int num=0;          System.out.println(Arrays.toString(sb));         //循环查找 循环里肯定这般操作         // 为什么使用while ？ 我已经 明确知道循环什么时候停止          // key 和中角标的值比较 如果相等 循环停止          while(a !=sb[mid]) {              if(a>sb[mid]) {                  min=mid+1;              }else if(a<sb[mid]) {                  max=mid-1;              }                //重复折半的操作               mid=(min+max)/2;               if(min>max) {                   mid=-1;                   break;               }              // 如果数组中没有这个数 会造成死循环              // 需要一个出口          }          System.out.println("坐标："+mid);}

二维数组(不是重点)

定义 二维数组也是个容器 保存 是多个一维数组 相同类型的一维数组

声明方式：

数据类型[][] 数据类型 =初值

举例

public static void main(String[] args) {        // TODO Auto-generated method stub        // 声明一个 有两个一维数组         // 并且每个数组中是三个元素的 二维数组        // 注意声明时需要把有几个一维数组声明出来        /*          int[][] sb= new int [2][3];          sb[0][0]=8;          System.out.println(sb[0][0]);*/        //声明方式2        // 声明一个 有3个一维数组 并且每个一维数组中有 4个元素 的一维数组        // 声明了个 3行4列的二维数组        int[][] sb=new int[][] {{3,4,2,2},{2,4,2,3},{2,3,4,5}};        //遍历二维数组        //array.length 二维数组的长度指的时有几个一维数组        for (int i = 0; i < sb.length; i++) {            for (int j = 0; j < sb[i].length; j++) {                System.out.print(sb[i][j]+" ");            }            System.out.println();        }    }