【Java基础】数组的基本操作、复制、扩容、排序以及在内存中的划分

最新推荐文章于 2021-02-24 21:37:33 发布
最新推荐文章于 2021-02-24 21:37:33 发布
阅读量201 收藏 2
点赞数
分类专栏： JavaSE 文章标签： java 数据结构 算法 指针 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42193813/article/details/107579819
版权

思维导图

数组

一、数组的概念

概念：一组连续的存储空间，存储多个相同类型的值

特点：类型相同、长度固定


二、数组的基本操作

2.1 创建数组

第一种方式

// 1 声明数组
int[] array1;
// 2 初始化数组
array1 = new int[12];

第二种方式

int[] array2 = new int[12];

第三种方式

int[] array4 = new int[]{1, 3, 1, 4};

第四中方式

int[] array3 = {5, 2, 0, 1, 3, 1, 4};

2.2 修改数组元素

array1[0] = 5;
array1[1] = 2;
array1[2] = 0;

2.3 访问数组元素

System.out.println(array1[0]);

2.3 遍历数组

常规遍历

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

for 增强遍历

for (int value : array1) {
    System.out.println(value);
}

2.4 小练习

给定一个整数数组，统计数组中所有元素的平均值

// 给定一个整数数组，统计数组中所有元素的平均值
public void averageCount() {
    int[] array = {12, 25, 99, 99, 3, 15, 1, 25};
    int sum = 0;
    double average = 0;
    for(int i = 0; i < array.length; i++) {
        sum += array[i];
    }
    average = sum / array.length;
    System.out.printf("%.2f", average);
}

给定一个整数数组，读入一个整数n,如果n在数组中存在,输出下标，不存在则输出-1

// 给定一个整数数组，读入一个整数n,如果n在数组中存在,输出下标，不存在则输出-1
public void judge() {
    int[] array = {5, 2, 0, 1, 3, 1, 4};
    boolean exist = false;
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    for(int i = 0; i < array.length; i++) {
        if (n == array[i]) {
            System.out.println("存在，下标: " + i);
            exist = true;
        }
    }
    if (!exist) {
        System.out.println(-1);
    }
}

控制台输入5个城市名称，用数组保存，并遍历输出

// 控制台输入5个城市名称，用数组保存，并遍历输出
public void saveCity() {
    String[] citys = new String[5];
    Scanner scanner = new Scanner(System.in);
    for(int i = 0; i < citys.length; i++) {
        String input = scanner.next();
        citys[i] = input;
    }
    for (String city : citys) {
        System.out.print(city + " ");
    }
}

三、数组在内存中的划分

数组属于引用类型

  • 栈：栈中存放数组的引用（地址）

  • 堆：堆中存放数组的内容

两个数组，在内存中的划分

在这里插入图片描述

将一个数组直接赋值给另一个数组时的内存图

  • 数组是引用类型，直接赋值时赋值的是数组的引用（地址）
  • 所以将array1的地址给array2时，它们两个在栈中存放的地址就是同一个了，指向堆中同一个位置
  • 所以当修改array1或者array2的时候，它们两个的值会同时变，因为是同一个内容
int[] array1 = {1, 2, 3};
int[] array2 = new int[3];

array2 = array1;

在这里插入图片描述


四、数组的常用操作

4.1 数组的复制

第一种方法：循环

public void arrayCopy1() {
    int[] array1 = {5, 2, 0};
    int[] array2 = new int[array1.length];
    for(int i = 0; i < array1.length; i++) {
        array2[i] = array1[i];
    }
    for (int value : array2) {
        System.out.print(value + " ");
    }
}

第二种方法：clone

public void arrayCopy2() {
    int[] array1 = {5, 2, 0};
    int[] array2;
    array2 = array1.clone();
    for (int value : array2) {
        System.out.print(value + " ");
    }
}

第三种方法：Arrays.copyOf()

public void arrayCopy3() {
    int[] array1 = {5, 2, 0};
    int[] array2;
    // 第一个参数：要复制的数组
    // 第二个参数：新数组的大小（如果新长度 > 原数组长度，则用0填充）
    array2 = Arrays.copyOf(array1, 5);
    for (int value : array2) {
        System.out.print(value + " "); // 结果: 5 2 0 0 0
    }
}

第四种方法：Arrays.copyOfRange()

public void arrayCopy4() {
    int[] oldArray = {5, 2, 0, 1, 3, 1, 4};
    int[] newArray;
    // 复制[0, 5)的数组元素 到新数组中
    // 如果复制长度 < 原数组长度，则就截取部分
    // 如果复制长度 > 原数组长度，则用0填充
    newArray = Arrays.copyOfRange(oldArray, 0, 5);
    for (int value : newArray) {
        System.out.print(value + " ");
    }
}

第五种方法：System.arraycopy()

public void arrayCopy5() {
    int[] oldArray = {5, 2, 0, 1, 3, 1, 4};
    int[] newArray = new int[oldArray.length];
    // 参数: (原数组 原数组起始下标 新数组 新数组起始下标 复制长度)
    // 也就是从原数组的0位置开始复制，复制到新数组从0开始的位置
    System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
    for (int value : newArray) {
        System.out.print(value + " ");
    }
}

4.1 数组的扩容

思路：

  1. 创建一个大于原数组的新数组
  2. 将原数组的元素复制到新数组中

就是将原数组中的元素，放到了一个更大的地方，就实现了扩容

/*
数组扩容
1. 创建一个大于原数组的新数组
2. 将原数组的元素复制到新数组中
 */
public int[] arrayExpand(int[] oldArray, int newLength) {
    int[] newArray = new int[newLength];
    if (newLength < oldArray.length) {
        System.out.println("扩容后的数组长度不能小于原数组长度");
    } else {
        // 将原数组的元素复制到新数组中
        newArray = Arrays.copyOf(oldArray, newLength);
    }
    return newArray;
}

方法测试

int[] oldArray = {5, 2, 0, 1, 3, 1, 4};

int[] newArray = arrayTest.arrayExpand(oldArray, 10);

结果

5 2 0 1 3 1 4 0 0 0

4.3 数组作为参数

参数传递时（数组是引用类型）

  • 如果传递的是基本数据类型，则传递的是值
  • 如果传递的是引用数据类型，则传递的是引用
    public static void printArray(int[] array) {
        for (int value : array) {
            System.out.print(value + " ");
        }
    }

因为数组是引用类型，传递的是引用

  • 当在其它地方修改数组时，两者的数据都会变
  • 因为实际上修改的那个数组和此数组指向的内存空间是一个地方，所以修改一个，另一个也会变

可变参数

  • 只能有一个
  • 必须在最后
public static void printArray(int... array) {
    for (int value : array) {
        System.out.print(value + " ");
    }
}

// 调用
printArray(12, 25, 99, 99);
printArray(newArray);

五、数组的排序

更详细的讲解： 冒泡排序， 选择排序，插入排序，希尔排序，快速排序

5.1 冒泡排序

// 冒泡排序
public int[] bubbleSort(int[] array) {
    for(int i = 0; i < array.length; i++) {
        for(int j = 0; j < array.length - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
    return array;
}

5.2 选择排序

// 选择排序
public int[] selectSort(int[] array) {
    for(int i = 0; i < array.length; i++) {
        int minIndex = i;
        for(int j = i + 1; j < array.length; j++) {
            if (array[minIndex] > array[j]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
    }
    return array;
}

5.3 插入排序

第一种方式

// 插入排序
public int[] insertSort(int[] array) {
    for(int i = 0; i < array.length; i++) {
        for(int j = i; j > 0; j--) {
            if (array[j] < array[j - 1]) {
                int temp = array[j];
                array[j] = array[j - 1];
                array[j - 1] = temp;
            }
        }
    }
    return array;
}

第二种方式

// 插入排序
public int[] insertSort2(int[] array) {
    for(int i = 0; i < array.length; i++) {
        int temp = array[i];
        int j = i;
        while (j > 0 && temp < array[j - 1]) {
            array[j] = array[j - 1];
            j--;
        }
        if (i !=j) {
            array[j] = temp;
        }
    }
    return array;
}

5.4 希尔排序

// 希尔排序
public int[] shellSort(int[] array) {
    int gap = array.length;
    while (true) {
        gap /= 2;
        for(int i = 0; i < gap; i++) {
            // 插入排序
            for(int j = i + gap; j < array.length; j += gap) {
                int temp = array[j]; // temp是取出的要比较的值
                int pos = j; // pos是向前移的指针
                // 向前找，如果找到更大的元素，则向后移
                while (pos > 0 && array[pos - gap] > temp) {
                    array[pos] = array[pos - gap];
                    pos -= gap; // pos指针向前移 步长gap
                }
                // 结束后，将temp交换到这里
                array[pos] = temp;
            }
        }
        if (gap == 1) {
            break;
        }
    }
    return array;
}

5.5 快速排序

// 快速排序
public void quickSort(int[] array, int low, int high) {
    if (low >= high) {
        return;
    }
    int pivot = array[low];
    int left = low;
    int right = high;
    while (low < high) {
        // 在右面找到第一个小于基准的数
        // 也就是大于基准时，high指针就左移
        while (low < high && pivot <= array[high]) {
            high--;
        }
        int temp = array[high];
        array[high] = array[low];
        array[low] = temp;

        // 在左面找到第一个大于基准的数
        // 也就是小于基准时，low指针就右移
        while (low < high && pivot >= array[low]) {
            low++;
        }
        temp = array[high];
        array[high] = array[low];
        array[low] = temp;

    }
    quickSort(array, left, low - 1);
    quickSort(array, low + 1, right);
}

六、多维数组

6.1 二维数组

// 二维数组
public void ArrayTwoTest() {
    // 创建二维数组
    int[][] array = new int[5][5];
    
    // 先声明，再分配空间
    int[][] array1;
    array1 = new int[3][3];

    // 创建二维数组并赋值
    int[][] array2 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    // 访问二维数组
    System.out.println(array[0][1]);

    // 二维数组赋值
    array[2][2] = 12;
    array[1][3] = 25;

    // 二维数组的遍历
    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();
    }
}

6.2 小练习

// 杨辉三角形
public void yanghui() {
    int[][] array = new int[12][];

    for(int i = 0; i < array.length; i++) {
        array[i] = new int[i + 1];
        // 填充空格
        for(int k = 0; k < array.length - i - 1; k++) {
            System.out.print(" ");
        }
        for(int j = 0; j < array[i].length; j++) {
            if (j == 0 || i == j) {
                array[i][j] = 1;
            } else {
                array[i][j] = array[i - 1][j - 1] + array[i - 1][j];
            }
            System.out.print(array[i][j] + " ");
        }
        System.out.println();
    }
}

七、查找算法

7.1 二分法查找

// 二分查找
public int binarySearch(int[] array, int target) {
    int low = 0;
    int high = array.length - 1;
    int mid = (low + high) / 2;
    while (low < high) {
        if (array[mid] == target) {
            return mid;
        } else if (target > array[mid]) {
            low = mid + 1;
        } else if (target < array[mid]) {
            high = mid - 1;
        }
        if (low == high) {
            return -1;
        }
        mid = (low +high) / 2;
    }
    return -1;
}

注意：二分法查找只能对有序序列进行查找

她的坏机器人
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java面试题及答案-非常全面（包括基础、网络、数据结构、算法及IT大厂面经）
11-16
- **扩容方式**：`HashMap`的扩容是在原有基础上翻倍再加1；`HashTable`的扩容是翻倍。 - **null键值**：`HashMap`可以接受一个null键和多个null值，而`HashTable`不允许。 - **性能**：通常情况下`HashMap`性能优于...
阿里面试回来，想和java程序员谈一谈
09-28
- **ArrayList**: 基于动态数组的数据结构，内部通过一个 Object 数组存储元素，提供了添加、删除等方法，并且支持自动扩容。 - **HashMap**: 基于哈希表的 Map 接口实现，不保证映射关系的顺序。内部通过 Node,V>[]...
数组 算法没有插入删除，只有存取和修改
沉淀
04-05 1414
#include using namespace std;/*数组逻辑结构：数组中元素本身就是 一种数据结构，可以帮二维数组当成 线性表的线性表。存储结构： 由于数组是固定的格式和数量的数据结合，不能做插入和删除的操作，只做存取和修改的操作，所以我们选择顺序存储结构。因为顺序存储结构在存取和修改时速度快（链式结构，在插入删除方面比较快）*//*数组的
数组的基础知识
杨森源的博客
05-28 6188
数组的定义：         数组是由一组类型相同的数据元素构成的有序集合，每个数据元素称为一个数组元素（简称为元素），每个元素受n(n≥1)个线性关系的约束，每个元素在n个线性关系中的序号i1、i2、…、in称为该元素的下标，并称该数组为 n 维数组。  数组的特点：         元素本身可以具有某种结构，属于同一数据类型； 数组是一个具有固定格式和数量的数据集合。
java使用工具类实现数组的拷贝，扩容，元素的前移
whyrookie的博客
06-14 171
关于java中数组的复制： 1.对数组进行扩容 Arrays.copyOf()方法，接收需要拷贝的数组和新数组长度，返回新数组 2.删除数组某个元素，后续元素前移 System.arraycopy(Objectsrc, intsrcPos, Objectdest, intdestPos, intlength)方法： Objectsrc：源数组 int srcPos：源数组删除数据位置的索引 Object dest：目标数组 int destPos：拷贝到目标数组开始的索引 int le...
数组复制和数组排序
weixin_43791033的博客
12-19 292
数组复制 语法：System.arraycopy(源数组名称，源数组复制开始索引，目标数组名，目标数组复制开始索引，长度); 数组A:1,2,3,4,5,6,7,8; 数组B:11,22,33,44,55,66,77,88; 将数组A的部分内容替换到数组B中，数组B的最终结果为：11，22，33，5，6，7，77，88； package shuzufuzhi; import java.securi...
数组扩容 java_Java数组扩容问题
weixin_42519488的博客
02-21 183
模拟扩容，由于不能使用方法，有些局限，可以运行看看。根据录入提示进行测试：package developer.test;/*** 默认创建一个长度为10的string数组，用户可以循环手动添加数据，当添加数据超过数组长度时，数组需要扩容，输入-1停止输入，不使用方法下去实现*/import java.util.Scanner;public class Test2 {public static vo...
java 高级工程师一些笔试题
08-11
了解它们的底层实现原理，比如ArrayList的动态扩容，HashMap的哈希冲突解决，以及红黑树在Set和Map中的应用。 7. **IO与NIO**：熟悉传统IO流的使用，理解缓冲流、转换流和对象流。而NIO（New IO）提供了非阻塞I/O...
java高级工程师面试题
12-12
综上所述，这些知识点覆盖了Java高级工程师面试中常见的几个领域，包括内存管理、垃圾回收机制、IO流处理、并发编程、锁机制、反射机制、类加载过程、对象序列化以及分布式唯一ID生成策略等。掌握这些核心概念和技术...
华为JAVA笔试题
11-09
【华为JAVA笔试题】主要涵盖了Java编程语言的基础概念、核心特性以及在实际开发中的应用。以下将详细解析可能出现在华为JAVA笔试题中的知识点。 1. **Java基础**：这部分包括了对Java语法的理解，如变量声明、数据...
随机快速排序的java代码
hello,黑豆先生
03-11 2663
public class Randomized_QuickSort {     public static void main(String[] args) {           Randomized_QuickSort rq = new Randomized_QuickSort();                   int a[] = { 54, 23, 75, 42, 45, 21
java 数组误差_要想数组用的 6，怎能不懂 java.util.Arrays
weixin_39593498的博客
02-19 85
java.util.Arrays 类就是为数组而生的专用工具类，基本上常见的对数组的操作，Arrays 类都考虑到了，这让我由衷地觉得，是时候给该类的作者 Josh Bloch、Neal Gafter、John Rose 点个赞了。(我是怎么知道作者名的？看源码就可以，小伙伴们，装逼吧)Arrays 都可以干嘛呢？常见的有：创建数组比较数组数组排序数组检索数组转流打印数组数组转 ListsetAl...
java中数组的拷贝和扩容
weixin_48703715的博客
07-20 214
1. 数组的拷贝（arraycopy（）方法） 使用：System.arraycopy(src, srcPos, dest, destPos, length); //第一个参数：原数组 //第二个参数：原数组元素的起始位置 //第三个参数：目标数组 //第四个参数：目标数组元素的起始位置 //第五个参数：长度 System.arraycopy(a, 2, b, 2, 2); System.out.println(Arrays.toString(b...
现在已知数组int[] arr = {12,34,465,3,45}; 要求创建一个新的数组,将arr的元素倒序放入新数组中, 然后求出数组中的最大值是多少?然后求出最大值的角标是第几个
weixin_43653670的博客
03-21 1352
现在已知数组int[] arr = {12,34,465,3,45}; 要求创建一个新的数组,将arr的元素倒序放入新数组中, 然后求出数组中的最大值是多少?然后求出最大值的角标是第几个 /* * 现在已知数组int[] arr = {12,34,465,3,45}; * 要求创建一个新的数组,将arr的元素倒序放入新数组中, * 然后求出数组中的最大值是多少?然后求出最大值的角标是第几...
数组的自动扩容问题
wang2639980860的博客
08-02 5556
一维数组的自动扩容；import java.util.Arrays;public class IntList { public static final int DEFAULT_ARRAY_COUNT = 16; int[] array; private int size = 0; public IntList() { array = new int[DEFA
JAVA练习关于continue、创建一个数组，其中放置12、-34、20、156、23.1、67、2.98、23.78、13.2和98共10个数，求其中最大数、最小数和平均数；
weixin_46605165的博客
11-01 168
1.continue 以及循环练习： 代码如下： package min; public class Lainxi { public static void main(String[]args){ int index=0; while(index<40){ index+=10; System.out.println(“index=”+index); } } } 运行截图： 2.更改代码、使程序输出跳过index=40; 代码如下: package min; public class Lainxi
java数组下标溢出报错程序_java程序eclipse报错Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2...
weixin_32059869的博客
02-24 251
我是想输入一个数，验证它满足哥德巴赫猜想。程序如下publicclassDay4T7{publicstaticvoidmain(Stringargs[]){System.out.println("请输入一个大于5的整数");Scannerscanner=newScann...我是想输入一个数，验证它满足哥德巴赫猜想。程序如下public class Day4T7 {public static vo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值