JavaSE第5篇:数组

文章目录

  • 一、数组简介
  • 二、一维数组的使用
  • 三、二维数组的使用
  • 四、数组的常见算法
  • 五 、Arrays工具类
  • 六、数组的常见异常
  • 总结


一、数组简介

1、多个相同类型的数据按一定的顺序排列的集合就是数组。其实数组就是一个容器

2、数组名、元素、 下标、 数组长度

3、数组是有序排列的

4、数组属于引用数据类型的变量、但是数组中的元素可以是任何数据类型(基本数据类型和引用数据类型)

5、数组的分类:

① 按维度:一维数组、二维数组(多维数组)

②按数组元素的类型:基本类型元素的数组、引用数据类型元素的数组

二、一维数组的使用

1、数组的声明和初始化

        int a; //变量的声明
        a = 1;//初始化
        int b = 1;//声明和初始化

        int array[]; //数组声明
        array = new int [2];  //初始化(数组是引用数据类型、必须是new关键字)
        //①静态初始化:数组的初始化和数组元素的赋值操作同时进行
        int n[] = new int[]{1,2,3};
        //②动态初始化:数组的初始化和数组的元素分开进行
        int n1[] = new int[3];
        //动态初始化
        int array [] = new int[5];
        //静态初始化
        int array1[] = new int[]{1,2};

数组一旦初始化其长度是确定的array.length

数组长度一旦确定、长度是不可能修改的

总结:数组一旦初始化完成、其长度是确定的

2、调用数组指定位置的元素
通过索引的方式调用、索引从0开始到数组的长度减1结束

        //动态初始化
        int array[] = new int[5];
        log.info(String.valueOf("长度:" + array.length));
        array[0]=1;
        
	     //获取字符串元素
        String s [] =new String[]{"12"};
        String s1 = s[0];
        char c = s1.charAt(1);
        System.out.println(c);

3、获取数组的长度

        String s [] =new String[]{"12"};
        int cd =s.length;

4、遍历数组的元素

        String s [] =new String[]{"12"};
        for (int i = 0; i <s.length ; i++) {
            System.out.println(s[i]);
        }

5、数组元素默认的初始化值
数组元素是整型 byte int short long 默认初始化值是0
数组元素是浮点型 float double 是0.0
数组元素是char类型 默认是0 这个0是ASCII码 或者是'\u0000' unicode码 而不是'0'
数组元素是boolean型 false
数组元素是引用数据类型时默认是null

6、数组的内存解析
简单的内存结构
JavaSE第5篇:数组_第1张图片
一维数组内存解析

JavaSE第5篇:数组_第2张图片

三、二维数组的使用

1、二维数组理解

我们可以看成一维数组array1作为另一个一维数组array2的元素存在的是二维数组(数组本身是引用数据类型)

2、二维数组使用
1、二维数组的声明和初始化
二维数组的元素就是一个数组

        //类型推断
        int a[] = {1, 2};
        //静态初始化
        int[][] array = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};

        //动态初始化
        int[][] array2 = new int[1][2];//行和列都行

        int[][] array3 = new int[1][];//行可以写 列可以去掉		     

2、二维数组调用数组指定位置的元素

        System.out.println(array[0][1]);
        String [][] array4 = new String[3][];
        array4[1] = new String[4];
        System.out.println(array4[1][0]);

JavaSE第5篇:数组_第3张图片

3、二维数组获取数组的长度

        int[][] array = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        System.out.println(array.length);
        System.out.println(array[0].length);

4、二维数组遍历

        //静态初始化
        //1   2   3
        //4   5
        //6   7   8   
        int[][] array = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};

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

        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.println(anInt);
            }
        }

5、二维数组元素默认的初始化值
规定:二维数组分为 外层数组元素 内层数组元素

        int [][] array =new int[2][3];
        //外层元素:array[0] array[1]
        //内存元素:array[0][0],array[1][2]
        System.out.println( array[0]);//地址值 [I@783e6358
        System.out.println( array[0][0]);//0
        double [][] array2 =new double[2][];
        System.out.println( array2[0]);//null
        System.out.println( array2[0][0]);//java.lang.NullPointerException

对于初始化方式一

比如int [][] array = new int[2][3]
外层元素初始化值为地址值
内存元素初始化值与一维数组初始化情况相同(看内存元素数据类型)

对于初始化方式二

int [][] array = new int[2][]
外层元素初始化值为null
内存元素初始化值不能调用 报错空指针

6、二维数组数组的内存解析

JavaSE第5篇:数组_第4张图片
数据结构
1、数据与数据之间的逻辑关系: 集合 一对一、 一对多、多对多

2、数据的存储结构:
线性表:顺序表(数组)、链表、栈、队列

树形结构:二叉树

图形结构

算法

排序算法

搜索算法

四、数组的常见算法

1、数值型元素数组的操作-最大值、最小值、平均数、总和

    @Test
    public void maxArrays() {
        int[] array = {10,22,34};
        int max =0;
//        for (int i = 0; i < array.length; i++) {
//            array[i] =(int) ((Math.random() * (99-10+1)) + 10);
//        }
        for (int i = 0; i < array.length; i++) {
           if(max<array[i]){
               max=array[i];
           }
           
        }

        System.out.println(max);
    }


    @Test
    public void minArrays() {
        int[] array = {10, 22, 34};
        int min = array[0];
//        for (int i = 0; i < array.length; i++) {
//            array[i] =(int) ((Math.random() * (99-10+1)) + 10);
//        }
        for (int i = 0; i < array.length; i++) {
            if (min > array[i]) {
                min = array[i];
            }

        }
        System.out.println(min);
    }

    @Test
    public void sumArrays() {
        int[] array = {1, 2, 3};
        int sum = 0;
//        for (int i = 0; i < array.length; i++) {
//            array[i] =(int) ((Math.random() * (99-10+1)) + 10);
//        }
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println(sum);
    }
    @Test
    public void avgArrays() {
        int[] array = {1, 2, 3};
        int sum = 0;
//        for (int i = 0; i < array.length; i++) {
//            array[i] =(int) ((Math.random() * (99-10+1)) + 10);
//        }
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
       //平均数
        int avg = sum/array.length;
        System.out.println(avg);
    }

2、数组赋值、复制

 //数组赋值
    @Test
    public void arrays1() {
       
        int[] array1, array2;
        array1 = new int[]{2, 3, 4};
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i] + "\t");
        }

        array2 = array1;
        //修改array2中的偶元素,使其等于索引值
        for (int i = 0; i < array2.length; i++) {
            if (i % 2 == 0) {
                array2[i] = i;
            }
        }

        System.out.println();
        //打印array1
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
    }

	 //数组复制
    @Test
    public void arrays2() {
        //数组复制
        int[] array1, array2;
        array1 = new int[]{2, 3, 4};
        array2 = new int[array1.length];
        for (int i = 0; i < array2.length; i++) {
            array2[i] = array1[i];
        }
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
    }

思考array1和array2地址值相同、都指向了堆空间的唯一一个数组实体

复制(区别与数组变量的赋值: array1 =array)

    @Test
    public void copyArrays() {
        String[] array1 = {"a", "b"};
        //复制操作就是在堆内存中在创建一个数组、数组长度为复制的数组的length
        String[] array2 = new String[array1.length];
        for (int i = 0; i < array1.length; i++) {
            array2[i] = array1[i];
        }
    }

二维数组赋值使用
JavaSE第5篇:数组_第5张图片

    @Test
    public void arrays2() {
     int array[][] = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
     int sum =0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                sum +=array[i][j];
            }
        }
        System.out.println(sum);
    }

JavaSE第5篇:数组_第6张图片JavaSE第5篇:数组_第7张图片


    @Test
    public void arrays2() {
        int[][] yanghui = new int[10][];

        for (int x = 0; x < yanghui.length; x++) {
            //给数组的元素赋值
            yanghui[x] = new int[x + 1];
            //给首末元素赋值
            yanghui[x][0] = 1;
            yanghui[x][x] = 1;

            //给每行的非首末元素赋值
            if (x >1) {
                for (int y = 1; y < yanghui[x].length-1; y++) {
                    yanghui[x][y] = yanghui[x - 1][y - 1] + yanghui[x - 1][y];
                }
            }

        }

        //打印
        for (int i = 0; i < yanghui.length; i++) {

            for (int i1 = 0; i1 < yanghui[i].length; i1++) {
                System.out.print(yanghui[i][i1] + " ");
            }
            System.out.println();
        }
    }


1

    @Test
    public void arrays3() {
        int[] array = new int[6];
        for (int i = 0; i < array.length; i++) {
            array[i] = (int) ((Math.random() * 30) + 1);
            for (int j = 0; j < i; j++) {
                if (array[i] == array[j]) {
                    i--;
                    break;
                }
            }
        }
        //遍历
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

回形算法
JavaSE第5篇:数组_第8张图片
JavaSE第5篇:数组_第9张图片

3、反转、查找(线性查找、二分法查找)

反转:就是两个变量进行交换

    @Test
    public void arrays3() {
//        int a =1;
//        int b =2;
//        int tem =a;
//        a =b;
//        b =tem;
//        System.out.println(a);
//        System.out.println(b);
        String[] array = new String[]{"AA", "BB", "CC", "DD"};
//        for (int i = 0; i < array.length / 2; i++) {
//            String temp = array[i];
//            array[i] = array[array.length - i - 1];
//            array[array.length - i - 1] = temp;
//        }

        for (int i = 0, j = array.length - 1; i < j; i++, j--) {
            String temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }

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


线性查找

        String[] array = new String[]{"AA", "BB", "CC", "DD"};

        String f = "BB";
        for (int i = 0; i < array.length; i++) {
            if(f.equals(array[i])){
                System.out.println(array[i]);
                break;
            }
        }

二分法查找
前期必须有序

    @Test
    public void arraysFen() {
        //二分法查找叫折半查找
        int a = -7;
        int array[] = {23, 33, 12, 3, -7, 55, 89, 0, 13, 11};
        boolean flag = true;
        int head = 0;//头部索引
        int end = array.length - 1;//尾部索引
        int mid = (head + end) / 2;//中间索引
        while (head < end) {
            if (a == array[mid]) {
                System.out.println("找到了指定元素,位置为:" + mid);
                flag =false;
                break;
            } else if (array[mid] > a) {
                end = mid - 1;
            } else {//array[mid]
                head = mid + 1;
            }
        }

        if(flag){
            System.out.println("没有找到");
        }
    }

4、排序

时间复杂度 空间复杂度 稳定性

内部排序在内存中完成

外部排序借助磁盘完成

JavaSE第5篇:数组_第10张图片

1、冒泡排序
思想:比较相邻的两个元素、第一个比第二个大、就交换他们两个

    @Test
    public void maopao() {
        int array[] = {44, 33, 12, 3, -7, 55, 89, 0, 13, 11};
        //array.length-1 外层长度减一 最后一个元素不需要比较 也可以比较不用减一
        for (int i = 0; i < array.length-1; i++) {
            //array.length-1-i
            // 内层长度:就是数组长度相邻比较后的次数就是长度减一
            // 减i:就是每比一次少个元素进行减i
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    int temp =array[j];
                    array[j] =array[j+1];
                    array[j+1]=temp;

                }

            }
        }

        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"\t");
        }
    }

2、快速排序
JavaSE第5篇:数组_第11张图片

五 、Arrays工具类

六、数组的常见异常

1、数组越界 java.lang.ArrayIndexOutOfBoundsException

2、空指针

总结

你可能感兴趣的:(Java基础,java)