9 2021-10-14

于 2021-10-14 22:29:05 发布
阅读量96 收藏
点赞数
分类专栏： 学习 文章标签： 算法 数据结构 小程序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56610296/article/details/120774207
版权

数组

数组的概述

  • 数组是相同类型数据的有序集合

  • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成

  • 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们

数组声明创建

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

dataType[] arrayTefVar=new dataType[arraySize];

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

  • 获取数组长度：arrays.length

  • 列：

public class arrayTest1 {
    public static void main(String[] args) {
        //变量的类型  变量的名字 = 变量的值；
        //数组类型 [] 数组的名字
        int[] nums1; //第一种定义方法推荐使用这种
        int nums2[]; //第二种定义方法早些年为了c语言的习惯定义
        int[] nums3 = new int[10];//第三种声明加创建
        nums1 = new int[10]; //这里可以存放10个int类型的数字了
        //给数组元素赋值
        nums1[0] = 1;
        nums1[1] = 2;
        nums1[2] = 3;
        nums1[3] = 4;
        nums1[4] = 5;
        nums1[5] = 6;
        nums1[6] = 7;
        nums1[7] = 8;
        nums1[8] = 9;
        nums1[9] = 100;
        //计算所有元素的和
        int sum = 0;
        //获取数组的长度 nums1.length
        for (int i = 0; i < nums1.length; i++) {
            sum += nums1[i];
        }
        System.out.println("总和为" + sum);
    }
总和为145
​
Process finished with exit code 0
    

三种初始化

  • 静态初始化

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

  • 动态初始化

nums1 = new int[3]; //这里可以存放3个int类型的数字了
//给数组元素赋值
nums1[0] = 1;
nums1[1] = 2;
nums1[2] = 3;

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

public class arrayTest2 {
    public static void main(String[] args) {
        //静态初始化
        int[] a = {1, 2, 3, 4, 5, 6};
        //动态初始化
        int[] b = new int[2];
        a[0] = 1;
        a[1] = 2;
    }
}

数组的基本特点

  • 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的

  • 其元素必须是相同类型，不允许出现混合类型

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

  • 数组本身就是对象，Java中对象实在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本省是在堆中的

Java的内存分析

图片：

 

  1. 具体不止这几个还有其他的分类

  2. 具体的分析

 

  1. 当输出第10个数是会报数组下标越界了的错误

数组的使用

  • For-Each循环

  1. 列：打印所有的数组，计算所有元素的和，查找最大元素。

public class arrayTest3 {
    public static void main(String[] args) {
        int[] array1 = new int[5];
        array1[0] = 1;
        array1[1] = 23;
        array1[2] = 5;
        array1[3] = 53;
        array1[4] = 9;
        //打印所有的数组
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        //计算所有元素的和
        int sum = 0;
        for (int j = 0; j < array1.length; j++) {
            sum += array1[j];
        }
        System.out.println("元素的和为:" + sum);
        //查找最大元素
        int max = array1[0];
        for (int a = 0; a < array1.length; a++) {
            if (array1[a] > max) {
                max = array1[a];
            }
        }
        System.out.println("最大元素为:" + max);
​
    }
}
1
23
5
53
9
元素的和为:91
最大元素为:53
​
Process finished with exit code 0

  • 数组作方法入参

  1. 列

public class arrayTest4 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        //JDK5没有下标,遍历数组
        printArray(arrays);
    }
    //打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}
1 2 3 4 5 
Process finished with exit code 0

  • 数组作返回值

  1. 列：键盘录入5个int类型的数据存储数组arr中，定义方法将arr数组中的内容反转，定义方法对反转后的数组进行遍历

import java.util.Scanner;
​
/*
 *  需求：
 *    (1)键盘录入5个int类型的数据存储数组arr中
 *    (2)定义方法将arr数组中的内容反转
 *    (3)定义方法对反转后的数组进行遍历
 * 分析：
 *    A:定义一个长度为5的数组
 *    B:通过键盘录入数据给数组中的元素赋值
 *    C:定义方法将arr数组中的内容反转
 *             什么是反转？ 如何实现反转
 *    D:定义方法对反转后的数组进行遍历
 *
 *
 *     */
public class arrayTest5 {
    public static void main(String[] args) {
        //定义1个5个数据的数组
        int[] arr = new int[5];
        //键盘录入数据
        Scanner sc = new Scanner(System.in);
​
        for (int x = 0; x < arr.length; x++) {
            System.out.println("请输入" + (x + 1) + "个元素值:");
            int num = sc.nextInt();
            //这里把输入的数据传入数组中且利用for循环传入5次
            arr[x] = num;
​
        }
        //反转前
        printArray(arr);
        reverse(arr);
        //写方法进行数组遍历
        printArray(arr);
    }
​
    //遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            //如果数组的索引是最后一个
            if (x == arr.length - 1) {
                System.out.println(arr[x] + "]");
            } else {
                System.out.print(arr[x] + ",");
            }
​
        }
    }
​
    //写方法 将数组中的内容反转 明确参数列表int[] arr 明确返回值 无返回值void
    public static void reverse(int[] arr) {
        for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
            //采用第三方变量的方式 把数组中的内容反转
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
​
        }
​
    }
}
请输入1个元素值:
1
请输入2个元素值:
2
请输入3个元素值:
3
请输入4个元素值:
4
请输入5个元素值:
5
[1,2,3,4,5]
[5,4,3,2,1]
​
Process finished with exit code 0
​

arr[x] = num;这里把输入的数据传入数组中且利用for循环传入5次

  1. 第二种方法使用返回值

import javax.swing.*;
import java.util.Scanner;
​
public class arrayTest6 {
    public static void main(String[] args) {
        //输入一个数决要输入几个数进行反转也就是定义数组的大小
        Scanner scanner1=new Scanner(System.in);
        System.out.println("请输入一个数决定要数输入的数:");
        int num1=scanner1.nextInt();
        int[] arrays=new int[num1];
        Scanner scanner2=new Scanner(System.in);
        //巧妙利用循环将输入的数据传入数组
        for (int i=0;i<arrays.length;i++){
            System.out.println("请输入" + (i + 1) + "个元素值:");
            int num2 =scanner2.nextInt();
            arrays[i] = num2;
        }
        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];
        }
        //返回result这个数组上面借用printArray这个方法进行打印
        return result;
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }
    }
请输入一个数决定要数输入的数:
7
请输入1个元素值:
1
请输入2个元素值:
2
请输入3个元素值:
3
请输入4个元素值:
4
请输入5个元素值:
5
请输入6个元素值:
6
请输入7个元素值:
7
7 6 5 4 3 2 1 
Process finished with exit code 0
​

多维数组

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

  • 二维数组

int[][] arrays = {{3, 1}, {3, 3}, {5, 5}, {6, 3}};

  • 二维数组arrays可以看成一个4行2列的数组第一行的数有3和1

  • 列：

public class arryTest7 {
    public static void main(String[] args) {
        int[][] arrays = {{3, 1}, {3, 3}, {5, 5}, {6, 3}};
        for (int i=0;i<arrays.length;i++){
            //这里表示里面的数组的长度时要用arrays[i].length;表示
            for (int j=0;j<arrays[i].length;j++){
                System.out.print(arrays[i][j]);
            }
            System.out.println();
        }
    }
}
31
33
55
63
​
Process finished with exit code 0

  1. 如果直接用System.out.println(arrays.length);输出数组它只能获取整体数组的长度即4，表示有4个一维数组

  2. 要想打印出二维数组就要用到循环进行嵌套，到第二个循环时里面的数组的长度时要arrays[i].length;表示(合理且巧妙的使用)

Arrays类

  • 数组的工具类Java.util.Arrays

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

  • 查看JDK帮助文档

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

  • 具有以下常用功能：

  1. 给数组赋值:通过fill方法

  2. 对数组排序:通过sort方法，按升序

  3. 比较数组:通过equals方法比较数组中元素值是否相等

  4. 查找数组元素:通过binarSearch方法能堆排序好的数组进行二分查找操作

  • 拓展当学习一个类的时候我们可以通过按住ctrl加左键打开这个类在点击左下角的structure可查看这个类中的所有方法

  • 列：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
​
public class arrayTest8 {
    public static void main(String[] args) {
        int[] a={2,4,5,6564,7,47,868,};
        //打印数组元素生成了[I@1b6d3586,hashcood编码
        System.out.println(a);
        //调用了Arrays中的toString方法
        System.out.println(Arrays.toString(a));
        //这里经常搞混，用自己写的方法只需要方法名加（）就可直接使用
        prinArray(a);
        /*将数组进行排序Arrays.sort,这里只进行排序而不进打印，
        打印需要用System.out.println进行输出，升序
         */
        Arrays.sort(a);
        System.out.println("\n"+Arrays.toString(a));
        //对数组进行填充
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
​
    }
    //自己也可以写一个方法取打印数组
    public static void prinArray(int[] a){
        for(int i=0; i<a.length; i++){
            System.out.print(a[i]+",");
        }
    }
​
}
[I@1b6d3586
[2, 4, 5, 6564, 7, 47, 868]
​
[2, 4, 5, 7, 47, 868, 6564]
[0, 0, 0, 0, 0, 0, 0]
​
Process finished with exit code 0
​

  1. 当打印数组的方法不正确出现I@1b6d3586的东西叫hashcood编码

  2. prinArray(a);这里经常搞混，用自己写的方法只需要方法名加（）就可直接使用

  3. 将数组进行排序Arrays.sort,这里只进行排序而不进打印，打印需要用System.out.println进行输出，默认是升序，想要降序的话需要使用其他的方法

  4. Arrays.fill(a,0);对数组进行填充，意思是数组中所有的元素都变为0

冒泡排序

violetdpc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值