第四章·数组

千羽³√

已于 2024-06-15 01:02:41 修改

阅读量899

点赞数 19

分类专栏： Java笔记文章标签： java 算法开发语言

于 2024-06-05 00:32:38 首次发布

本文链接：https://blog.csdn.net/qq_57111018/article/details/139457035

版权

Java笔记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

第四章·数组

概念

数组是具有相同数据类型的有序数据的集合，它是一个对象。使用一些标识符作为数组名，数组中的每一个数据称为数组元素。每个数组元素都可以通过下标来访问他们。

理解

属于引用数据类型
长度一但定义之后就不能扩展，是固定的
数组其实和变量差不多，变量只能存一个数，数组可以定义一堆相同的数据类型
数组可以存放基本数据类型或对象
一个具有注脚的文本。
元素类型必须相同，不能混合类型
数组元素可以是任何数据类型
数组对象本身在堆中

一维数组

概念

是一组具有相同数据类型变量的线性集合

声明格式

数组类型[] 数组名；
数组类型数组名[]；

分配空间

通过数组名和数组元素在线性结构中的序号，称为小标，来确定数组元素，下标从0开始。

初始化

静态初始化：（声明的同时赋值）

格式

int [] a={...,...,...};

动态初始化：（先声明后赋值）

注意：利用new运算符为数组分配内存空间，赋值（小标从0开始）

格式

int[] a;
a= new int[长度]
或者
int [] b=new int [长度]

注意：在给数组赋值的时候一定不能超过数组规定空间大小，否则会产生溢出问题

数组元素的使用

当数组创建并初始化后，就可以使用数组中的各元素了

获取数组的长度length

方法

数组名.length

例子

package com.ydl.ch004.h001;

public class quchang {
    public static void main(String[] args) {
        int []a=new int[3];
        a[0]=1000;
        a[1]=1800;
        a[2]=1500;
        //如果当数组a[3]=1600时，则数组越界异常：ArrayIndexOutOfBoundsException
        int b=a.length;
        System.out.println(b);
    }
}
//输出：3
//给a的数组长度是3，设变量b来获取a的长度，所以最后b的长度为3

求最值

package com.ydl.ch004.h001;

public class zuizhi01 {
    public static void main(String[] args) {
        // 求最大值
        int a[]={3,5,8,1,2,6};
        int max=a[0];
        int xao=a[0];
        for (int i=0;i<a.length;i++){
            if(a[i]>max){
                max=a[i];
            }
        }
        System.out.println(max);
        
// 求最小值
        for (int q=0;q<a.length;q++){
            if(a[q]<xao){
                xao=a[q];
            }
        }
        System.out.println(xao);
    }

}输出：8   1

package zh.ch004.h001;

import java.util.Arrays;

public class shuzudaxiaozuizhi {
    //    求该数组的元素最大值，最小值：先排序，再输出a[5]和a[0]
    public static void main(String[] args) {
        int i=0;
        int sum=0;
        int[]a=new int[6];int c=0;
        int j;
        a[0]=4;
        a[1]=2;
        a[2]=0;
        a[3]=-8;
        a[4]=23;
        a[5]=9;
        Arrays.sort(a);//数组从小到大排序
        for(i=0;i<a.length;i++){
            
        }
        System.out.println(a[5]);//得出最大值
        System.out.println(a[0]);//得出最小值
    }
}

求平均值

package com.ydl.ch004.h001;
/* 1.定义一个数组{4，2，0，-8，23，9}
        求该数组的元素平均值，总和:先定义一个sum装数组所有元素的和，再for输出平均值*/
public class pingjunzhi {
    public static void main(String[] args) {
        int i=0;
        int sum=0;
        int[]a=new int[6];int c=0;
        int j;
        a[0]=4;
        a[1]=2;
        a[2]=0;
        a[3]=-8;
        a[4]=23;
        a[5]=9;
        for (int b:a){
            sum=sum+b;
        }
        System.out.println(sum);
        System.out.println(sum/5);
    }
}
输出：30   6

遍历数组：（使用数组中的每一个元素）

使用普通for循环遍历数组

package day05;
/*循环三要素：i代表下标
        * 初始化：int i=0
        * 条件： i<a.length
        * 改变：i++
        * */
public class 遍历数组01 {
    public static void main(String[] args) {
        int []a=new int[10];
        for (int i=0;i<a.length;i++){//遍历a数组
            a[i]=(int)(Math.random()*100);//随机数 
            System.out.println(a[i]);//输出每个元素的值
        }
    }
}

增强for循环遍历数组

其实也是for循环的一种，相当于for循环puls版本，在增强for语法格式中，不需要提供初始化，不需要条件，不需要改变

语法格式：

for(数据类型 变量名 : 数组名称){
   语句块;
}

数组的拷贝（copy）：

拷贝原理

将一个数组中的所有元素放到另外一个数组中，两个数组的长度一致，元素数据一致

使用循环来实现拷贝

public static void main(String[] args) {
        //方式1： 使用循环完成数组拷贝
        int array1 []={1,2,3,4,5};//原数组

        int array2[]=new int [array1.length];//定义一个新的数组，开辟的空间大小和原数组一样大（array1.length）
        //遍历原数组array1,并且将数组的元素赋值给新的数组array 2
        for(int i=0;i<array1.length;i++){
            array2[i]=array1[i];//将array1中元素的值赋值给array2
            System.out.println(array2[i]);
        }
    }

思路

先定义一个新的数组，数组大小和原数组一致，使用循环将原数组中的所有元素遍历出来并且赋值给新的数组

使用clone()

直接通过数组名.clone()即可调用

package day05;
//clone方法
public class 数组拷贝03 {
    public static void main(String[] args) {
        int[]a=new int[6];
        a[0]=4;
        a[1]=2;
        a[2]=0;
        a[3]=-8;
        a[4]=23;
        a[5]=9;
        int a1[]=a.clone();//拷贝
        for (int d:a1){//遍历拷贝后的数组
            System.out.println(d);
        }
    }
}

System.arrayCopy（）

原数组，起始位置（下标，即从第几个开始拷贝），拷贝后的数组，起始位置，数组长度

package day05;
import java.util.Arrays;
//System.arrayCopy()
public class 数组拷贝01 {
        public static void main(String[] args) {
            // 定义两个数组
            int[] arr1 = {1, 2, 3, 4, 5};
            int[] arr2 = new int[arr1.length];

            // 使用 System.arraycopy() 方法实现数组的拷贝
            //            原数组名 下标 新的数组名 下标 数组的长度
            System.arraycopy(arr1, 0, arr2, 0, arr1.length);
            // 打印数组
            System.out.println("arr1 = " + Arrays.toString(arr1));
            System.out.println("arr2 = " + Arrays.toString(arr2));
        }
    }

Arrays.Copyof()

package day05;

import java.lang.reflect.Array;
import java.util.Arrays;

//Arrays.Copyof()：数组的扩容(创建了一个更大的新的数组，并将数据复制进去了)
public class 数组拷贝02 {
    public static void main(String[] args) {
         int a[]={3,5,7,1};
        int b[]=Arrays.copyOf(a,4);
        System.out.println(b);
    }
}

求和

原理

遍历数组中的每个元素，将每个元素进行加法运算，并且使用盒子（变量）装起来

代码实现

 package day05;

public class 数组求和 {
    public static void main(String[] args) {
        int m[] ={4,2,0,-8,23,9};//静态初始化数组
        int sum=0;//专门用来存放元素总和
        //3.求数组元素的总和
        for (int i=0;i<m.length;i++){
            sum=sum+m[i];
        }
        System.out.println("各个元素总和为"+sum);
    }
}

排序

默认是升序

Arrays.sort(数组名)；

例子

package com.ydl.ch004.h002;
//Arrays.sort():排序
import java.util.Arrays;
public class paixu {
    public static void main(String[] args) {
        int[]a={4,5,8,1,3,0,2,7};
        Arrays.sort(a);
       for(int b:a){
           System.out.print(b);
       }

    }

}
//输出：01234578

数组反转

将原来的数组进行遍历，将原数组中的第一个元素的值赋值给新数组中的最后一个元素，以此类推

例子

package day05;

public class 数组反转 {
    public static void main(String[] args) {
        //数组的反转：
        int m[]={1,2,3,4,5};
        int arr2[]=new int [m.length];
        for (int i=0,t=m.length-1;i<m.length;i++,t--){
            //i 变量代表原数组的下标，是从0开始的，t变量代表新数组的下标，是从5开始
            arr2[t]=m[i];
            System.out.print(m[t]);
        }
    }
}//54321

package com.ydl.ch004.h002;

public class fanzhuan01 {
    public static void main(String[] args) {
        int a[]={2,4,8,5,6,1};
        int a1[]=new int[a.length];
        for(int i=0,j=a.length-1;i<a.length;i++,j--){//i变量代表原始的下标，是从0开始的，j变量代表新数组，是从5开始
            a1[i]=a[j];
            System.out.print(a1[i]);
        }
    }
}
//165842

package day05;

public class 数组反转01 {
    public static void main(String[] args) {
        int i=0;
        int sum=0;
        int[]a=new int[6];int c=0;
        int j;
        a[0]=4;
        a[1]=2;
        a[2]=0;
        a[3]=-8;
        a[4]=23;
        a[5]=9;
        int k;
        int t;
        int n=6;
        for (i=0;i<n/2;i++) {
            t = a[i];
            a[i] = a[n - i - 1];
            a[n - i - 1] = t;
        }
        for (k=0;k<n;k++){
            System.out.print(a[k]+"\t");
        }

    }
}//9	23	-8	0	2	4

填充替换数组元素

fill()方法

为每个元素填充：

package day05;

import java.util.Arrays;
//为每个元素填充/替换
public class 全部填充替换数组 {
    public static void main(String[] args) {
        int[] a = {1, 5, 8, 2, 7};
        for (int item : a) {
            System.out.print(item + "\t");
        }
        System.out.println();
        Arrays.fill(a,8);//将全部元素替换成8
        System.out.println("使用fill填充后值为：");
        for (int item:a){
            System.out.print(item + "\t");
         }
        System.out.println();
    }
}
//使用fill填充后值为：
88888

指定范围元素填充：

该方法填充的范围从下标索引fromlndex（包括）开始一直到下标索引tolndex（不包括）。如果fromlndex==tolndex，则填充为空。

package day05;

import java.util.Arrays;

public class 指定范围元素填充 {
    public static void main(String[] args) {
        int[] a = {1, 5, 8, 2, 7};
        for (int item : a) {
            System.out.print(item + "\t");
        }
        System.out.println();
        Arrays.fill(a,1,4,8);
        System.out.println("使用fill填充后值为：");
        for (int item:a) {
            System.out.print(item + "\t");
        }
        System.out.println();
    }
}

//输出：使用fill填充后值为：18887

数组元素的查找

使用binarySearch()方法在数组中查找元素下标

package day05;

import java.util.Arrays;
import java.util.Scanner;

//binarySearch()
public class 数组元素查找 {
    public static void main(String[] args) {
        int [] b={3,6,8,9,1};
        System.out.println("数组排序为：");
        Arrays.sort(b);//数组排序
        for (int m:b){
            System.out.print(m);
        }
        System.out.println("");
        System.out.println("请输入要查找的数组元素：");
        Scanner j=new Scanner(System.in);
        int f=j.nextInt();
        int a;
        a= Arrays.binarySearch(b,f);
        if(a>0){
            System.out.print("要查找的数组元素下标位置为："+a);}
        else{
            System.out.println("不存在");
        }
    }
}

//输出：以输入6为例子
数组排序为：
13689
请输入要查找的数组元素：
6
要查找的数组元素下标位置为：2

二维数组

初始化

静态初始化（声明的同时赋值）

格式

数据类型 [][] 数组名称=｛｛｝，｛｝，｛｝｝

例子

int [][] k={{1,2},{3,12},{2,48}}

注意：

在进行赋值的时候一定赋值的类型是和定义数组的数据类型一致

动态初始化（先声明后赋值）

格式

通过下标进行赋值

[][]

数据类型 [][] 数组名称 =new 数据类型 [大小][大小];//定义数组并且开辟空间大小
数组名称[大框框的下标][小框框的下标]=数值；

直接赋值

（在声明的时候直接规定行和列的空间大小）

  int n[][] = new int[2][2];
        //再赋值
        b[0][0] = 1;
        b[0][1] = 2;
        b[1][0] = 3;
        b[1][1] = 4;

逐级赋值

在声明的过程当中只是规定了一维数组的长度，如果要进行赋值的话，就需要先将每个大框框中有多少个空间先规定出来

        int k[][] = new int[3][];//在这里开辟了3个大框框，但是大框框中有多少个小框框并没有指定
        k[0] = new int[2];//规定第一个大框框中有两个小框框
        k[1] = new int[3];//规定第二个大框框中有三个小框框
        k[0][0] = 3;//按照下标再进行赋值

默认初始化

数组的遍历

先使用外层循环将外面大框框先遍历出来，遍历出来之后的结果为多个一维数组（小框框），再使用内层循环将多个小框框的结果遍历出来，此时遍历的就是数组里面的每个元素

原始二维数组：
｛｛张三，李四，王二｝，｛马腾，马小云，许科｝｝
外层for()----->｛张三，李四，王二}  ,｛马腾，马小云，许科｝       ------> 还是一个数组
内层for()----->张三，李四，王二   马腾，马小云，许科             ------>  拿到单个元素

使用普通for循环遍历数组

package day05;

public class 二维数组for遍历 {
    public static void main(String[] args) {
        int n[][]={{2,3},{3,5},{5,6}};
        //5.1 普通for循环遍历数组
        //需要使用两层循环，外层循环拿到的结果是多个大框框，内层循环才是每个元素
        System.out.println("使用普通for循环遍历数组的结果：");
        for(int i=0;i<n.length;i++){           //此时会遍历得到n[0][未知] n[1][未知]
            for(int j=0;j<n[i].length;j++){    //此时遍历的就是n[0] n[1],此时拿到的结果才回事数组中的元素
                System.out.print(n[i][j]+"\t");//2	3	3	5	5	6
            }
        }
    }
}

使用增强for循环遍历数组

package day05;

public class 二维数组增强for遍历 {
    public static void main(String[] args) {
        int n[][]={{2,3},{3,5},{5,6}};
        for(int i[] :n){   //外层循环能够拿到的是多个数组，所以在：之前需要使用数组给他存起来
            for (int j:i){ //内层循环能够拿到的是具体元素，使用在：之前需要使用的就是变量给他存起来
                System.out.print(j+"\t");//2	3	3	5	5	6
            }
        }
    }
}

二维数组最值

最大值

先暂定最大值为数组中的第一个元素，遍历数组，将数组中的每个元素都和最大值进行比较，如果比他大，则替换大他

代码：

package day05;

public class 二维数组最大值 {
    public static void main(String[] args) {
        //定义二维数组
        int[][] a = {{12, 1, 6}, {28, -3, 3}, {19, 23, -31}};
        int max = a[0][0];
        for (int i = 0; i < a.length; i++) {
            /*  a[i][未知]；*/
            for (int j = 0; j < a[i].length; j++) {
                /*a[i][j]*/
                if (a[i][j] > max) {
                    max = a[i][j];
                }
            }
        }
        System.out.println(max);//28
    }
}

最小值

先暂定最小值为第一个元素，遍历数组，将数组中的元素和最小值进行比较，如果比他小，则替换掉他

代码：

 package day05;

public class 二维数组最小值 {
    public static void main(String[] args) {
        //定义二维数组
        int[][] a = {{12, 1, 6}, {28, -3, 3}, {19, 23, -31}};
        int min = a[0][0];//暂定最小值为第一个元素
        //最小值
        for (int i= 0;i<a.length;i++){
            /* a[i][未知]*/
            for (int j=0;j<a[i].length;j++){
                /* a[i][j];*/
                if (a[i][j]<min){
                    min=a[i][j];
                }
            }
        }
        System.out.println(min);//-31
    }
}

补充

**Scanner类：**获取控制台输入。它是一个工具类，属于java.util包。
**用法：**Scanner console = new Scanner(System.in);//定义一个Scanner类
**方法：**console.nextInt();//输入整数
console.nextLine();//输入字符串
console.nextDouble() ;//输入小数

**lRandom类：**实现的随机算法是伪随机，也就是有规则的随机。
**用法：**Random random = new Random();
方法： random.nextInt();//随机整数
random.nextInt(int n);//随机返回[0，n)之间的整数
random. nextDouble();//随机返回[0.0,1.0)之间的小数
**Math 类：**用于执行基本数学运算的方法，如初等指数、对数、平方根和三
角函数。
Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值
公式：Math.random()*(n-m)+m，生成大于等于m小于n的随机数；

public class TestMath {
public static void main(String[] args) { System.out.println(Math.abs(-2.0));//绝对值
System.out.println(Math.sqrt(64.0)); //立方根
System.out.println(Math.max(56,78)); //两者之间较大的
System.out.println(Math.min(56,78)); //两者之间较小的
System.out.println(Math.random()); //随机数
System.out.println(Math.pow(2,10)); //幂
System.out.println(Math.ceil(18.36)); //向上取整
System.out.println(Math.floor(18.66)); //向下取整
System.out.println(Math.round(11.5)); //四舍五入
System.out.println(Math.round(-11.5)); //四舍五入
}
}

常用单词

1)for:为了、循环的一种
2)continue:继续
3)array/arr:数组
4)length:长度
5)multiplication:乘法
6)table:表格
7)addition:加法
8)index:下标、索引
9)out of:超出
10)bounds:界限
11)exception:异常
12)copy:复制
13)arraycopy/copyOf:数组复制
14)max:最大值
15)min:最小值
16)sort:顺序、排序