java之数组小知识

最新推荐文章于 2024-10-16 10:13:45 发布

dszy18

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量155

点赞数

文章标签： java

本文链接：https://blog.csdn.net/dszy18/article/details/78690809

版权

数组

数组练习

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 又确定 一个数

  看图

  ![这里写图片描述](https://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();
        }


    }