java数组

于 2021-07-13 16:40:14 发布
阅读量138 收藏 1
点赞数 2
CC 4.0 BY-SA版权
分类专栏： java 文章标签： java 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_47840823/article/details/118703313
本文详细介绍了Java中的数组，包括声明、创建、内存分析、初始化方式、特点、使用方法如普通for循环和增强型for循环，以及数组作为方法参数和返回值。还涉及了二维数组、Arrays类的使用、冒泡排序算法以及稀疏数组的概念和转换。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.数组

定义：数组是相同类型数据的有序集合
 

1.1数组的声明和创建

1.声明：首先必须声明数组变量，才能在程序中使用数组

int[] nums;   //首选方法
int nums[];

2.创建：new

nums = new int[10];//在这里存放10个int类型的数据

3.索引：通过下标

4.综上的一个代码

public class Demo1 {
    public static void main(String[] args) {

        int[] nums = new int[10];      //声明+创建：在这里存放10个int类型的数据
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;
        System.out.println(nums[1]);   //索引
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum+nums[i];
        }
        System.out.println(sum);
    }
}

 

1.2内存分析

​                   堆：存放new的对象和数组

java内存---- 栈：存放基本变量类型

​                   方法区：包含了所有class和static变量

 
关于数组的内存分析如下：

在这里插入图片描述

 

1.3三种初始化

1.3.1静态初始化

int[] a= {1,2,3,4};
System.out.println(a[0]);

1.3.2动态初始化

int[] b = new int[10];
b[0]=10;
System.out.println(b[0]);

1.3.3数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，它的每一个元素也被按照实例变量同样的方式被隐式初始化。（int默认初始化为0，string默认初始化为null）

1.4数组的特点

1.数组的长度是确定的，它的大小不可以被改变

2.一个数组的元素必须是相同类型的

3.数组中的元素可以是任意数据类型，包括基本类型和引用类型

4.数组也是对象

 

1.5数组的使用

1.5.1普通的for循环

public class Demo3 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        
        //打印数组
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        
        //数组求和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
           sum += arrays[i];

        }
        System.out.println("sum="+sum);
        
        //数组中的最大值
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (max<arrays[i]){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);
        
    }
}

1.5.2增强型for循环

int[] arrays ={1,2,3,4,5};
      for (int array : arrays){
         System.out.println(array);
      }

1.5.3数组做方法入参

public class Demo4 {
    public static void main(String[] args) {
        int[] arrays ={1,2,3,4,5};
        printArray(arrays);                //打印数组元素
    }
        public static void printArray(int[] arrays){
            for (int i = 0; i < arrays.length; i++) {
                System.out.println("arrays="+arrays[i]);
            }
        }
}

1.5.4数组做返回值

public class Demo4 {
    public static void main(String[] args) {
        int[] arrays ={1,2,3,4,5};
        int[] reverse = reverse(arrays);
         printArray(reverse);                   //打印反转数组
    }
        public static  int[] reverse(int[] arrays) {
            int[] result = new int[arrays.length];
            for (int i = 0, j = result.length-1; i < arrays.length; i++, j--) {
                result[j] = arrays[i];
            }
            return result;
        }
}

在这里插入图片描述

1.6二维数组

定义：

int[][] array = new int[2][5];       //两行五列的数组

使用:

public class Demo5 {
    public static void main(String[] args) {
        int[][] array = {{1, 2}, {2, 3}, {3, 4}};        //三行两列
        System.out.println(array[1][1]);                 //3
        System.out.println(array.length);                //外围数组长度=3
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);         //打印出所有元素
            }
        }
    }
}

1.7Arrays类(JDK帮助文档)

数组的工具类Arrays

import java.util.Arrays;

public class Demo6 {
    public static void main(String[] args) {
        int[] a= {1,3,4,56,789,607,6,90};
        System.out.println(a);                    //[I@1540e19d
        
        System.out.println(Arrays.toString(a));   //打印数组[1, 3, 4, 56, 789, 607, 6, 90]
        
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));   //排序，升序[1, 3, 4, 6, 56, 90, 607,789]
        
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));   //填充[1, 3, 0, 0, 56, 90, 607, 789]
    }
}

1.8冒泡排序(Bubble Sort)

八种排序算法，冒泡排序最为出名

冒泡排序：两两做比较，小的前移（时间复杂度为O(n2)）

步骤：1.比较数组中两个相邻的元素，如果前一个数字比后一个大，交换位置

​           2.每一次比较都会产生一个最大或者最小的数字

          ​ 3.下一轮可以少一次排序

​           4.依次循环，直至结束

import java.util.Arrays;
public class Demo7 {
    public static void main(String[] args) {
        int[] a ={1,34,5,690,42,58,90,12,57};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));

    }
    public static int[] sort(int[] array){
        int temp = 0;                         //临时变量
        
        //外层循环，判断我们要比较多少次
        for (int i = 0; i < array.length-1; i++) {
           
            boolean flag = false;            //优化冒泡排序,flag标志位减少不必要的比较

            //内层循环，比较这两个数，交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
        }
        return array;
    }
}

1.9稀疏数组

1.稀疏数组是一种数据结构

2.引言：五子棋中使用二维数组来表示所下的棋子，“1”代表黑棋，“2”代表白棋，其余默认值都为“0”，因此记录了很多没有意义的数据---------解决方法：稀疏数组。

3.定义：当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该该数组。

4.处理方式：记录数组一共有几行几列，有多少个不同值

​                     把具有不同值的 元素 和 行列 及 值 记录在小规模数组中，从而缩小程序的规模。

在这里插入图片描述

五子棋代码：

public class Demo8 {
    public static void main(String[] args) {
        //棋盘11*11，创建一个二维数组，0代表无棋子，1代表黑棋，2代表白棋
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        System.out.println("输出原始数组");
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        
        //转换为稀疏数组保存
        //1.计算有效值个数
        int sum =0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数："+sum);
        
        //2.创建一个稀疏数组
        int[][] array1 = new int[sum+1][3];
        array1[0][0] = 11;
        array1[0][1] = 11;
        array1[0][2] = sum;
        
        //3.遍历二维数组。将非零数值存放于稀疏数组中
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0){
                    count++;
                    array1[count][0] = i;
                    array1[count][1] = j;
                    array1[count][2] = array[i][j];
                }
            }
        }
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i][0]+"\t"+array1[i][1]+"\t"+array1[i][2]+"\t");
        }
        
        System.out.println("稀疏数组还原");
        
        //1.读取稀疏数组
        int[][] array2 = new int[array1[0][0]][array1[0][1]];
        
        //2、给其中的元素还原它的值
        for (int i = 1; i < array1.length; i++) {
            array2[array1[i][0]][array1[i][1]] = array1[i][2];
        }
        
        //3.打印还原数组
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

输出结果：

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值