java学习之数组

数组

数组的定义:保存一组相同数据类型的数据

数据类型 变量名=初值

声明数组格式:数据类型[] 数组名=初值

注意:这里的数据类型 指的是 数组中保存的数据的类型

数组的长度一旦确定,就不能更改了

数组如何存取?  使用下标存取 下标从0开始

int[] array=new int[数组的长度];

数组的三种声明方式:

 //数组声明方式一

    int[] array=new int[数组的长度];
 //数组声明方式二(又给长度又给元素)
    int array=new int[] {1,3,5,11};
 //数组声明数组方式三
    int[] array= {1,2,3,4,5};

int[] array= new int[5];

new表示跟堆内存中,开辟块内存空间

栈内存特点

1.当函数执行完毕 系统会自动帮你释放

2.先进后出

数组的遍历(打印数组中所有的元素)

数组练习

 1.根据角标查找对应的元素

 2.根据元素查找对应的角标

    public class Demo03 {

        //需求: 封装一个函数 传入数字1 返回 一  

        //数字2 返回 二 ..... 数字5 返回 五

public static char findStringToIndex(int index) {

        // 声明一个数组

char[] charArray = {'一','二','三','四','五' };

                return charArray[index-1];

}

public static void main(String[] args) {

char c = findStringToIndex(1);

System.out.println(c);

int key1 = 11;

int[] array1 = new int[] {3,6,11,22};

int a = findIndexTokey(array1, key1);

System.out.println(a);

    }

 }

数组元素 反转

  1,3,5,7 --> 7,5,3,1
  如何交换两个数?
  int a = 10;
  int b = 15;
  定义声明一个临时变量
  int temp = 0;
  temp = a;
  a = b;
  b = temp;

反转数组

public static void changeArray(int[] arr) {

int num = arr.length/2;

for (int i = 0; i < num; i++) {

int temp = arr[i];

arr[i] = arr[arr.length - 1 - i];

arr[arr.length - 1 - i] = temp;

}

    }

冒泡排序

   核心思想:相邻两个数比较 换位

   内循环 控制一共比了多少趟

   外循环 控制一趟比了多少次

    public class Demo05 {

           public static void main(String[] args) {

            int[] array = {3,2,5,1};

            for (int i = 0; i < array.length-1; i++) {

                    for (int j = 0; j < array.length-1-i; j++) {

                //判断大小 相邻

                //内循环-1 防止数组越界

                //内循环-1 循环一次 确定一个数 每次都少比一次

                    if (array[j]>array[j+1]) {

                       //交换

                    int temp=array[j];

                    array[j]=array[j+1];

                    array[j+1]=temp;

                    }

                }

            }

      }

}

选择排序

  核心思想:选择一个数(选第一个数)和其他的数进行比较 交换

    public class Demo06 {

        public static void main(String[] args) {

        int[] array= {3,2,5,1};

        for (int i = 0; i < args.length-1; i++) {

        for (int j = 1+i; j < args.length; j++) {

                //用第0个数 和剩下的每一个数比较

                //i=0 j 1,2,3...

                //i=1 j 2,3...

                //i=2 j 3...

        if (array[i]>array[j]) {

            //交换

            int temp=array[i];

                array[i]=array[j];

                array[j]=temp;

                    }

                }

             }

        }

   }

折半查找

(必须是有序的数组)

public class Demo07 {

public static void main(String[] args) {

        int[] array= {1,22,33,44,55,66};

        int key=55;

        int min=0;

        int max=array.length-1;

        int mid=(min+max)/2;

                    //循环---明确知道循环的停止条件

        while(array[mid]!=key) {

                //判断 key和中间角标值 

                //来挪动 最小角标或最大角标

            if (key>array[mid]) {

                min=mid+1;

            }

            if (key<array[mid]) {

            max=mid-1;

    }

                //每次循环都要有折半的操作

            mid=(min+max)/2;

                //数组中没有这个数的时候

            if (min>max) {

                //没有这个数 使用-1表示;

                    mid=-1;

            break;//跳出循环

           }

    }

            System.out.println("该值得坐标是:"+mid);

        }

    }

 二维数组

      保存多个相同类型的一维数组

      (几维数组 就几个[])

      数据类型[][] 数组名=初值;

   三维数组

      保存多个相同类型的二维数组

     public class Demo08 {

        public static void main(String[] args) {

                //声明一个二维数组

                //这个二维数组中 有两个一维数组

                //每个一维数组中有三个元素

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

                //array.length 表示有几个一维数组

        System.out.println(array.length);

                //声明方式二

                //1.1,11,111/2,22,222

            int[][] array1=new int[][]{

            {1,11,111},

            {2,22,222},

        };

              //遍历

    for (int i = 0; i < array1.length; i++) {

    for (int j = 0; j < array1[i].length; j++) {

            System.out.println(array1[i][j]+"  ");

       }

            System.out.println();

            }

       }

  }