JAVA学习09（数组）

最新推荐文章于 2022-08-15 09:05:42 发布
最新推荐文章于 2022-08-15 09:05:42 发布
阅读量117 收藏
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Insist_C/article/details/121382297
版权

数组

数组概述

数组的定义：

  1. 数组是相同类型数据的有序集合
  2. 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
  3. 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们

数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRwfVar;//首选的方法
或
dataType arrayRefVar[];//效果相同，但不是首选方法

Java语言中使用new操作符来创建数组，语法如下:

dataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的，数组索引从0开始。

获取数组长度：

arrays.length

public class ArrayDemo01 {
    //变量的类型   变量的名字  =  变量的值；
    //数组类型
    public static void main(String[] args) {
        int[] nums;//1.声明一个数组

        nums = new int[10];//2.创建一个数组
        int[] nums2 = new int[10];

        //给数组元素赋值
        nums[0] = 0;
        nums[1] = 1;
        nums[2] = 2;
        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[7]);

        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println("总和为：" + sum);


    }
}

内存分析

Java内存：

堆：

  1. 存放new的对象和数组
  2. 可以被所有的线程共享，不会存放别的对象引用

栈：

  1. 存放基本变量类型（会包含这个基本类型的具体数值）
  2. 引用对象的变量（会存放这个引用在对立面的具体地址）

方法区：

  1. 可以被所有的线程共享
  2. 包含了所有的class和static变量

三种初始化

静态初始化：

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化：

int[] a = new int[2];
a[0] = 10;
a[1] = 15;

数组的默认初始化：

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的四个基本特点

  1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
  2. 其元素必须是相同类型，不允许出现混合类型
  3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
  4. 数组变量属引用类型，数组也可看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组边界

下标的合法区间：[0,length-1]，如果越界就会报错；

public static void main(String[] args) {
    int[] a = new int[2];
    System.out.println(a[2]);
}
报错：ArrayIndexOutOfBoundsException

小结：

  1. 数组是相同的数据类型（数据类型可以是任意类型）的有序集合
  2. 数组也是对象。数组元素相当于对象的成员变量
  3. 数组长度是确定的，不可变的。如果越界，则报错（ArrayIndexOutOfBoundsException）

数组使用

for-each循环（没有下标）：

public static void main(String[] args) {
    int[] arrays = {1,2,3,4,5};

    //JDK1.5 ,没有下标
    for (int array : arrays) {
        System.out.println(array);
    }

普通的for循环

数组作方法入参

数组作返回值

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //JDK1.5 ,没有下标
        for (int array : arrays) {
            System.out.println(array);
        }
//        //打印全部的数组元素
//        for (int i = 0; i < arrays.length; i++) {
//            System.out.println(arrays[i]);
//        }
//        System.out.println("==================");
//        //计算所有元素的和
//        int sum = 0;
//        for (int i = 0; i < arrays.length; i++) {
//            sum += arrays[i];
//
//        }
//        System.out.println("sum=" + sum);
//        System.out.println("=================");
//        //查找最大元素
//        int max = arrays[0];
//        for (int i = 1; i < arrays.length; i++) {
//            if(arrays[i] > max){
//                max = arrays[i];
//            }
//        }
//        System.out.println("最大元素为：" + max);
    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组：

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

解析：以上数组a可以看成一个两行三列的数组。

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

Arrays类

数组的工具类java.util.Arrays

由于数组对象本身并没有什么方法可以供我们使用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。

查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而”不用“使用对象来调用（注意：是”不用“而不是”不能“）

具有以下常用功能：

  1. 给数组赋值：通过fill方法。
  2. 对数组排序：通过sort方法，按升序。
  3. 比较数组：通过equals方法比较数组中元素值是否相等。
  4. 查找数组元素：通过brinarySearch方法能对排序好的数组进行二分查找法操作。
public class ArraysDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,4,3,5634,34,765,3456};
        //System.out.println(a);
        //printArray(a);

        //打印数组元素Arrays.toString(a)
        //System.out.println(Arrays.toString(a));

        Arrays.sort(a);//数组进行排序
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4,0);//数组填充
        System.out.println(Arrays.toString(a));

    }
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i == 0){
                System.out.print("[" + a[i] + ", ");
            }else if (i == a.length - 1){
                System.out.print(a[i] + "]");
            }else {
                System.out.print(a[i] + ", ");
            }
        }
    }

}

冒泡排序

冒泡排序两层循环，外层冒泡轮数，里层依次比较。

嵌套循环，时间复杂度为O（n^2）

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {1,34,65,3,566,13,4536,2342};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));


        //冒泡排序
        //1.比较数组中两个相邻的元素，如果有第一个数比第二个数大，就交换他们的位置
        //2、每一次比较，都会产生一个最大，或者最小的数字
        //3.下一轮，可以少一次排序
        //4.依次循环，直至结束！

    }
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        boolean flag = false;//通过flag标识位减少没有意义的比较
        //外层循环,判断我们这个循环要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环：比较判断两个数，如果第一个数比第二个数大，则交换位置
            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;
    }
}

稀疏数组（数据结构）

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

稀疏数组的处理方式是：

  1. 记录数组一共有几行几列，有多少个不同值
  2. 把具有不同值的元素和行列以及值记录在一个小规模的数组中，从而缩小程序的规模

在这里插入图片描述
32922)(C:\Users\19252\Desktop\QQ图片20211117111202.png)]

public class ArrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*22   0：没有棋子  1：黑棋    2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;
        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=============================");
        //转换为稀疏数组来保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数为：" + sum);

        //2.创建一个稀疏数组的数组
        int[][] array2= new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历二维数组，将非零的值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1] + "\t"
                    +array2[i][2] + "\t");
        }

        System.out.println("===================");
        System.out.println("还原");
        //1.读取稀疏数组的值
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中元素还原值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //3.打印
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

取稀疏数组的值
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中元素还原值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}

    //3.打印
    for (int[] ints : array1) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
}

}
Insist_C
关注
【Java实现数组的插入优化】
leach
03-28 689
头插，尾插的插入效率 在之前的插入中是【直接让currentIndex++我们在填入数据】 现在我们把他们分为头插和尾插和中间插入 中间插入：【在插入index的位置以后移动一位然后在index的位置中插入我 们的数据】 public void add(int data,int index){ // 是否扩容 currentIndex++; if (currentIndex>nums.length-2){ int tager[]=new i
用数组来进行头插法，尾插法，删除，修改，查询，遍历数据
m0_52410507的博客
05-20 712
首先创建一个数组，定义一个变量来控制数组元素的有限个数， 在使用过程中，数组元素超过开辟的数组个数时，要开辟新的数组空间。开辟空间的长度大小是原来长度的1.5倍。 private int[] element;//定义一个element数组 private int size;//控制数组当中有效数字的个数 //创建一个MyArrayList的数组 public MyArrayList() { element = new int[10];//...
JAVASE基础（五）
qq_62288582的博客
10-08 89
数组 一、数组概述 数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个数组元素，每个数组元素可以通过下一个下标来访问它们。 二、数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法： dataType[] arrayRefVar;//首选方法 dataType arrayRefVar[];//效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下： dataType[] arrayR
java实现在数组头和数组尾部插入一个元素（函数封装）
辰风的博客
03-14 3610
一、题目描述 定义一个数组arr[10]，在数组的头部插入一个元素0，然后输出 0 ，第一个元素，第二个元素… 定义一个数组arr[10]，在数组的尾部插入一个元素5，然后输出第一个元素 ， … ，5 二 、代码实现 头部插入： import java.util.Scanner; public class example01 { public static void Init(...
【java】数组插入处理
weixin_46014378的博客
03-07 183
数组插入处理 题目描述 已有一个已正序排好的9个元素的数组，今输入一个数要求按原来排序的规律将它插入数组中。 输入 第一行，原始数列。 第二行，需要插入的数字。 输出 排序后的数列 样例输入 1 7 8 17 23 24 59 62 101 50 样例输出 1 7 8 17 23 24 50 59 62 101 import java.util.*; public class Main { ...
一维数组的头插法和尾插法
qq_41241541的博客
03-23 1821
public class Practise2 { //尾插法 public static int[] addTail(int[] arr,int value){ for(int i=0;i<arr.length;i++){ if(arr[i]==0) { arr[i]=value; break; } } return arr; } //头插法 public static int[] addH...
Java中使用数组完成学生成绩统计的多种实现代码清单.pdf
07-11
在Java编程语言中，数组是一种基础且重要的数据结构，用于存储同类型的数据集合。在处理学生成绩统计这类问题时，数组能有效地帮助我们组织和计算数据。以下将详细讲解两个不同的Java代码方案，它们利用数组来完成...
java语言中数组的基础教程学习资料适用新手
最新发布
12-27
java语言中数组的基础教程学习资料适用新手java语言中数组的基础教程学习资料适用新手java语言中数组的基础教程学习资料适用新手java语言中数组的基础教程学习资料适用新手java语言中数组的基础教程学习资料适用新手...
java实例-数组（学习资料）
06-17
接着，我们学习如何向数组中添加元素。`insertElement()`方法接收原始数组、要插入的元素和插入位置作为参数。如果元素1在排序后的数组中不存在（如本例中，`binarySearch()`返回负数），那么它的插入位置可以计算...
Java学习资料-数组
06-15
Java中的数组是编程中不可或缺的基础概念，主要用于存储一组相同类型的元素。数组的使用极大地提高了代码的效率和可读性，特别是在处理大量数据时。数组有三个核心特性：一致性（所有元素同类型）、有序性（通过下标...
java关于数组（学习笔记）
12-21
Java中的数组是一种重要的数据结构，它允许我们存储多个同类型的元素。数组被定义为一个容器，可以一次性容纳多个数据项，这些数据项在内存中是连续存放的，这使得访问和检索元素非常高效。在Java中，数组属于引用...
Java实现头插法
ythswzgxlp的博客
08-15 555
头插法
Java数组插入
li20010310的博客
01-10 2796
觉得小编写的不错的，点点赞，点点关注。谢谢！ import java.util.Scanner; public class Demo02 { public static void main(String[] args) { //插入数组 int [] num=new int[6]; num[0]=99; num[1]=85; num[2]=78; num[3]=65; num[4]=63; int index = 0; //位置下标 Scanner input
java list 在头部添加_java中List的用法
weixin_39960116的博客
02-25 1万+
|--List:元素是有序的(怎么存的就怎么取出来，顺序不会乱)，元素可以重复(角标1上有个3，角标2上也可以有个3)因为该集合体系有索引，|--ArrayList：底层的数据结构使用的是数组结构(数组长度是可变的百分之五十延长)(特点是查询很快，但增删较慢)线程不同步|-- LinkedList：底层的数据结构是链表结构(特点是查询较慢，增删较快)|--Vector：底层是数组数据结构线程同步(...
Java代码实现数组中插入数据
聪明的阿呆
04-13 4万+
public class ListInsert { public static long[] insert(long[] arr,int i,long l){ //新建数组,对原数组扩容 long[] arr1 = new long[arr.length+1]; //将原数组数据赋值给新数组 for(int j = 0;j<arr.length;j++){ arr1[j]
java数组如何添加元素
qq_30908729的博客
04-22 1万+
java数组如何添加元素？解决方法：http://www.yayihouse.com/yayishuwu/chapter/1186
java如何向数组里添加元素
热门推荐
newy的博客
09-14 27万+
java篇 哇，菜鸟第一次写这个东西，当加深印象，大佬们请略过，欢迎有错指出。 向数组里添加一个元素怎么添加，这儿总结有三种方法： 1、一般数组是不能添加元素的，因为他们在初始化时就已定好长度了，不能改变长度。 但有个可以改变大小的数组为ArrayList，即可以定义一个ArrayList数组，然后用add(element)方法往里添加元素即可，还可add(index,element)往指...
数组头部添加元素
weixin_30607659的博客
12-04 6592
在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组输入例子:prepend([1, 2, 3, 4], 10) 输出例子:[10, 1, 2, 3, 4] function prepend(arr, item) { return [item].concat(arr); } 　　 function prepend(arr, i...
[Python]数据结构--链表
Festinatione facit vastum
01-11 651
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
Java学习：数组赋值与输出
"这篇资源是关于Java编程的课程资料，主要讲解了如何为数组赋值并进行输出。在Java中，数组是一种数据结构，可以存储多个相同类型的数据...这个资源适合初学者了解Java编程基础，特别是数组操作和Java学习的整体框架。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值