个人学习---Java数组

Java数组

数组定义

数组是相同类型数据的有序集合,为一种最简单的数据结构,按照一定的先后次序排列组合而成。其中,每一个数据称为数值元素,每个数组元素可通过索引(下标)来进行访问。

注:在Java中,数组索引从0开始。

数组的声明与创建

声明

在Java语言中,数组的声明有两种形式,如下式所示。

int[] array;
int arrays[];

两种定义方式效果相同,但一般采用前者作为首选方案

注:

  1. 声明数组时,数组并不存在。

  2. 数组类型由变量类型 + "[ ]" 两部分组成。

创建

在Java语言中,使用new操作符来创建数组,如下图所示。

个人学习---Java数组_第1张图片

其中:数组尺寸表示数组的大小内容,即可以存放10个int类型的数字

注:如果数组中最后的几个索引中没有赋值,则会赋默认值。Int类型赋0值,Sting类型赋null值,如下图所示。

个人学习---Java数组_第2张图片

Java内存分析

Java内存空间分为堆、栈、方法区等,如下表所示。

名称 功能
用于存放new的对象和数组,可以被所有的线程所共享,不会存放其他的对象引用。
存放基本变量类型(会包含这个基本类型的具体数值)。存放引用对象的变量(会存放这个引用在堆里的具体地址)。
方法区 可以被所有线程共享,包含了所有的class和static变量

注:在声明数组时,将数组压入栈中;创建数组时,转入堆中创建,在堆中开辟了空间并对空间进行划分,在堆中实现对数组的赋值。

数组初始化

在Java中,数组具有三种初始化方法:

  1. 静态初始化 ,如下式所示。

    int[] a = {1, 2, 3};
  2. 动态初始化 ,如下式所示。

    int[] b = new int[10];
  3. 默认初始化:数组也是一种引用类型,它的元素相当于类中的实例变量。因此,数组一经分配空间,其中每个元素也按照与实例变量相同的方式被隐式初始化,即赋默认值:int[ ]为0;String[ ]为null

    关于实例变量,点击此处了解

注:数组基本特点包括以下四个方面:

  1. 数组的长度是确定的,一旦创建,大小不允许改变

  2. 数组的元素必须是相同类型,元素类型不能混合。

  3. 数组元素可以是任意数据类型。

  4. 数组变量是一种引用类型,数组本身为对象,数组元素相当于对象的成员变量。在Java中,无论数组中存放基本类型还是其他对象类型,数组对象本身是在中存放的。

数组边界

下标的合法区间在 [0, length-1],如果超过边界会报错,如下图所示。

个人学习---Java数组_第3张图片

注:可通过数组名 + "." + length 来获得数组的长度。

数组基础使用

  1. 数组可通过循环语句来打印出全部元素并实现部分简单功能,如下图所示。

    个人学习---Java数组_第4张图片
  2. 使用加强for循环,更容易遍历输出数组元素,如下图所示。

    个人学习---Java数组_第5张图片

    注:没有索引(下标),不方便具体操作。

  3. 数组可以作为方法的参数,如下图所示。

    个人学习---Java数组_第6张图片

    注:当数组作为传入参数时,传递的是引用地址的拷贝,但是拷贝的地址和真实的地址都指向一个真实数据,因此改动形参,实参也会发生改动。

    补充:Java是值传递,当传递的是基本类型时,传得是值的拷贝,故修改形参并不影响实参;当传递的是引用类型时,传得是引用地址的拷贝,但拷贝地址和原始地址都指向一个真实的值,故修改形参会影响实参的结果;当传递封装类和String类时,虽然是它们是引用类型,但是由于其本质是由final修饰的,不能被修改,所以作为传参时实参是不会跟随形参发生改变的。

  4. 数组可以作为方法返回值,如下图所示。

    个人学习---Java数组_第7张图片

多维数组

多位数组可以看成数组的数组,本质为数组的嵌套。以二维数组为例,二维数组中的每一个元素都为一个一位数组,多维数组以此类推。

二维数组的创建,如下式所示。

        //静态初始化
        int[][] arrays = {{2,3},{4,5},{5,6}};
        //动态初始化
        int[][] arrays2 = new int[3][2];

结果,如下图所示。

个人学习---Java数组_第8张图片

注:图中的二维数组arrays_2可以看成一个三行两列的数组,与arrays_1表示相同。

补充:

arrays_1.length表示为二维数组的长度,即内部有多少个一维数组。arrays_1[0].length表示为在二维数组中,下标为0的一维数组中的元素个数。

二维数组的加强for循环输出,由下图所示。

个人学习---Java数组_第9张图片

Arrays类(数组工具类)

常用方法

  1. 打印数组元素,使用Arrays.toString()方法,如下图所示。

    个人学习---Java数组_第10张图片
  2. 排序数组(升序),使用Arrays.sort()方法,如下图所示。

    个人学习---Java数组_第11张图片
  3. 给数组赋值,使用Arrays.fill()方法,如下图所示。

    个人学习---Java数组_第12张图片
  4. 比较数组中数值是否相等,使用Arrays.equals()方法,如下图所示。

    个人学习---Java数组_第13张图片
  5. 查找数组元素,能对排好序的数组来进行二分法查找,返回所查找数字的索引,使用Arrays.binarySearch()方法,如下图所示。

    个人学习---Java数组_第14张图片

注:Arrays类中的方法都为static修饰的静态方法,直接用类名调用即可。(用对象来调用也行)

冒泡排序

冒泡算法为最出名的排序算法之一,它是通过元素之间两两比较,谁小或谁大就进行前移或后移。在冒泡算法中,外层为冒泡轮数,内层依次比较,如下图所示。

个人学习---Java数组_第15张图片

注:可以通过设置标志位来减少没有意义的比较,即若标志位没发生变化,则表示以及排好,退出即可,如下图所示。

个人学习---Java数组_第16张图片

稀疏算法

  • 稀疏算法是一种压缩算法,用于处理数组中记录很多无意义的数据。

  • 适用范围:当一个数组中大部分元素为0或者为同一元素值数组。

  • 处理方式:**记录数组有几行几列,有多少不同的值,后将记录结果记录在一个小规模数组中。

    具体流程,如下图所示。

    个人学习---Java数组_第17张图片

实现代码,如下所示。

import java.util.Scanner;
​
public class ArrayDemo5 {
    static int line = 4;
    static int col = 4;
    final static int sparseCol = 3;
​
    public static void main(String[] args) {
        int[][] nums = new int[line][col];
        int sum = 0;
        nums = inPut(line,col);
        outOldPut(nums);
​
        sum = count(nums);
        int[][] sparseNums = new int[sum+1][sparseCol];
        sparseNums = draw(nums, sum);
        outSparsePut(sparseNums);
​
        int[][] backNums = new int[line][col];
        backNums = back(sparseNums);
        outBackPut(backNums);
    }
    public static int[][] inPut(int line, int col){
        int[][] arrays2 = new int[line][col];
        System.out.println("请输入数组内容:");
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < arrays2.length; i++) {
            for (int j = 0; j < arrays2[i].length; j++) {
                if(scanner.hasNextInt()){
                    arrays2[i][j] = scanner.nextInt();
                }
            }
        }
        scanner.close();
        return arrays2;
    }
    public static void outOldPut(int[][] nums){
        System.out.println("输出原始数组为:");
        for (int i = 0; i < nums.length; i++) {
            for(int j = 0; j < nums[i].length ; j++) {
                System.out.print(nums[i][j] + "\t");
                if(j==nums[i].length-1){
                    System.out.println();
                }
            }
        }
        System.out.println("====================");
    }
    public static void outSparsePut(int[][] nums){
        System.out.println("输出稀疏数组为:");
        for (int i = 0; i < nums.length; i++) {
            for(int j = 0; j < nums[i].length ; j++) {
                System.out.print(nums[i][j] + "\t");
                if(j==nums[i].length-1){
                    System.out.println();
                }
            }
        }
        System.out.println("====================");
    }
    public static void outBackPut(int[][] nums){
        System.out.println("输出还原数组为:");
        //使用加强for循环输出二维数组。
        for (int[] i:nums) {
            for(int j :i) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
        System.out.println("====================");
    }
    public static int count(int[][] nums){
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                if (nums[i][j]!=0){
                    count++;
                }
            }
        }
        return count;
    }
    public static int[][] draw(int[][] nums, int sum){
        int[][] sparseNums = new int[sum+1][sparseCol];
        sparseNums[0][0] = line;
        sparseNums[0][1] = col;
        sparseNums[0][2] = sum;
        int count = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                if (nums[i][j]!=0){
                    sparseNums[count][0] = i;
                    sparseNums[count][1] = j;
                    sparseNums[count][2] = nums[i][j];
                    count++;
                }
            }
        }
        return sparseNums;
    }
    public static int[][] back(int[][] sparseNums){
        int[][] backNums = new int[line][col];
        for (int i = 1; i < sparseNums.length; i++) {
            backNums[sparseNums[i][0]][sparseNums[i][1]] = sparseNums[i][2];
        }
        return backNums;
    }
}

你可能感兴趣的:(java,学习,intellij-idea)