（四）java中数组的使用

已于 2022-12-03 23:50:19 修改
阅读量513 收藏 1
点赞数
分类专栏： java 文章标签： java 开发语言 算法
于 2022-12-03 23:47:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XCL1670/article/details/128168305
版权

文章目录

十六.数组的使用

  • 数组是多个相同类型数据的组合，实现对这些数据的统一管理。

  • 数组中的元素可以是任意数据类型，包括基本类型和引用类型，但是不能混合用

  • 数组创建后，如果没有进行扶着，有默认值。

    byte 0，short 0，int 0，long 0，float 0 ，double 0，char \u0000，boolean false，String null。

  • 使用数组的步骤：使用数组并开辟空间，给数组的各个元素进行复制，使用数组

  • 数组的下标从0开始的

  • 数组的下标必须在指定范围内使用，否则就会数组越界。

  • 数组属于引用类型，数组数据的对象是object。

import java.util.Scanner;

public class array {
    public static void main(String[] args) {
        //创建一个char类型的26个元素的数组，分别放置'A'-'Z'.使用for循环访问所有元素并打印出来。
        char[] chars = new char[26];
        for (int i = 0; i < chars.length; i++ ) {
            chars[i] = (char)('A' + i);//这里由于'A' + i是int型，需要强制转换
        }
        System.out.println("chars数组如下：");
        for (int i = 0 ; i < chars.length; i++) {
            System.out.print(chars[i] + "  ");
        }
    }
}

public class array02 {
    public static void main(String[] args) {
        //请求出一个数组int[]的最大值{4，-1，9，10，23},并得到相应的下标，并求出其平均值。
        int[] arrays = {4, -1, 9, 10, 23};
        int max = arrays[0];
        int maxindex = 0;
        int sum = 4;
        double avg = 0;

        for (int i = 1; i < arrays.length; i++ ) {
            if (arrays[i] > max) {
                max = arrays[i];
                maxindex = i;
            }
            sum += arrays[i];
        }
        avg = sum / arrays.length;
        System.out.println("该数组的最大值为：" + max);
        System.out.println("其对应的下标为：" + maxindex);
        System.out.println("其平均值为：" + avg);

    }
}
数组的赋值机制
  1. 基本数据类型赋值，这个值就是具体的数据，而且是互不影响的。
  2. 数组在默认的情况下是引用传递的，赋的值是地址。
int[] arr1 = {1,2,3};
int[] arr2 = arr1;
arr2[0] = 10;
//赋值方式是引用赋值，arr2的变换会影响到arr1.
System.out.println("arr1的元素为：");
for (int i = 1; i < arrays.length; i++ ) {
    System.out.println(arr1[i]);
}
一维数组的JVM内存布局

​ 值传递 / 值拷贝和引用传递 / 地址拷贝的区别：

​ 值传递的时候相当于值拷贝，将原先的数值拷贝的一份，与之前的数据互不影响。

​ 数组指向的是一个地址，引用传递的时候指向的一个地址，在传递的时候只是将地址复制了一份。

​ 在这里插入图片描述

int[] arr1 = {10.20.30};
int[] arr2 = new int[arr1.length];//arr2重新开辟了新的空间，与之前的地址互不影响

在这里插入图片描述

public class array03 {
    public static void main(String[] args) {
        //数组交换
        int[] arrs = {11, 22, 33, 44, 55, 66};
        int a = 0;
        int len = arrs.length;
        for (int i = 0; i < len / 2; i++) {
            a = arrs[len - i - 1];
            arrs[len - i - 1] = arrs[i];
            arrs[i] = a;
        }
        System.out.println("数组倒序排列后的结果如下：");
        for (int i = 0; i < arrs.length; i++) {
            System.out.print(arrs[i] + "  ");
        }
    }
}

public class array04 {
    public static void main(String[] args) {
        //数组的扩容
        int[] arr = {1, 2, 3};
        int[] arrNew = new int[arr.length + 1]; //定义一个新数组
        for (int  i = 0; i < arr.length ; i++ ) {
            arrNew[i] = arr[i];
        }
        arrNew[arrNew.length - 1] = 4;
        arr = arrNew; 
        System.out.println("数组扩容后的结果如下：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

import java.util.Scanner;

public class array05 {
    public static void main(String[] args) {
        //动态数组的扩容,每次在最后添加一个元素
        Scanner lll = new Scanner(System.in);

        int[] arr = {1, 2, 3};
        do {
            int[] arrNew = new int[arr.length + 1]; //定义一个新数组
            for (int  i = 0; i < arr.length ; i++ ) {
                arrNew[i] = arr[i];
            }

            System.out.println("请输入您要添加的元素：");
            int add1 = lll.nextInt();

            arrNew[arrNew.length - 1] = add1;
            arr = arrNew;

            System.out.println("数组扩容后的结果如下：");
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }

            System.out.println("");
            System.out.println("您是否还要继续添加(y/n):");
            char add2 = lll.next().charAt(0);

            if ( add2 == 'n') {
                break;
            } else if (add2 == 'y') {
                continue;
            } else {
                System.out.println("您输入的语法错误！！！");
                break;
            }

        } while (true);

        System.out.println("程序结束");
    }
}

import java.util.Scanner;

public class array06 {
    public static void main(String[] args) {
        //数组的动态缩减
        //有一个数组{1，2，3，4，5}，可以将该数组进行缩减，提示用户能否继续进行缩减，每次缩减最后的元素，当只剩下最后的一个元素，提示，不能在进行缩减，
        Scanner lll = new Scanner(System.in);

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

        System.out.println("您最初的数组是{1，2，3，4，5}");

        do {
            System.out.println("您是否要继续缩减(y/n):");

            char add2 = lll.next().charAt(0);

            if ( add2 == 'n') {
                break;
            } else if (add2 == 'y') {

                if (arr.length == 1) {

                    System.out.println("数组长度达到最小值，不能再进行缩减！！！");
                    break;
                }

                int[] arrNew = new int[arr.length - 1]; //定义一个新数组

                for (int  i = 0; i < arrNew.length ; i++ ) {
                    arrNew[i] = arr[i];
                }

                arr = arrNew;

                System.out.println("数组缩减后的结果如下：");

                for (int i = 0; i < arr.length; i++) {
                    System.out.print(arr[i] + " ");
                }

                System.out.println("");

            } else {

                System.out.println("您输入的语法错误！！！");
                break;
            }

        } while (true);

        System.out.println("程序结束");
    }
}
冒泡排序

在这里插入图片描述

​ 原理：通俗的来讲就是两个两个重复多轮的进行比较，每执行一轮排序就能进行得到一个结果数。

​ 特点：

  1. 每执行一轮排序就可以确定一个数的位置，比如第一轮排序确定最大的数，第二轮排序确定第二大的数。
  2. 当进行比较时，如果前面的数字大于后面的数字，就进行交换。
  3. 每一轮比较的次数都在减少。有n个数据，第一轮排序需要排n-1，第二轮排序需要排n-2次。以此类推。
public class bubble_order {
    public static void main(String[] args) {
        //冒泡排序(从大到小排列)
        int[] arr = {24, 69, 80, 57, 13};
        int aaa = 0;
        for (int i = 0 ; i < arr.length - 1 ; i++ ) {
            for (int j = 0; j < arr.length - 1 - i ; j++) {
                if (arr[j] > arr[j + 1]) {
                    aaa = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = aaa;
                }
            }
        }
        System.out.println("冒泡排序后的结果为：");
        for (int k = 0; k < arr.length; k++) {
            System.out.print(arr[k] + " ");
        }
    }
}

public class bubble_order2 {
    public static void main(String[] args) {
        //冒泡排序(从小到大排列)
        int[] arr = {24, 69, 80, 57, 13};
        int aaa = 0;
        for (int i = 0 ; i < arr.length - 1 ; i++ ) {
            for (int j = 0; j < arr.length - 1 - i ; j++) {
                if (arr[j] < arr[j + 1]) {//这里改个符号即可从小到大进行排列
                    aaa = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = aaa;
                }
            }
        }
        System.out.println("冒泡排序后的结果为：");
        for (int k = 0; k < arr.length; k++) {
            System.out.print(arr[k] + " ");
        }
    }
}
查找
import java.util.Scanner;

public class inquire {
    public static void main(String[] args) {
        //查找
        String[] names = {"狗子", "猴子", "胖子", "瘦子", "绝绝子"};
        Scanner lll = new Scanner(System.in);

        System.out.println("请输入您要查询的名字");
        String findName = lll.next();
        int tag = 0;//设置标记

        for (int i = 0; i < names.length ; i++ ) {
            if (findName.equals(names[i])) {
                System.out.println("恭喜找到：" + findName);
                System.out.println("下标为：" + i);

                tag = 1;
                break;
            }
        }
        if (tag == 0) {
            System.out.println("对不起，没有找到名字:" + findName);
        }

    }
}
二维数组
import java.util.Scanner;

public class array07 {
	public static void main(String[] args) {
		//输出一个二维数组
		int[][] arr = {
			{1, 2, 3, 4, 5, 6},
			{1, 2, 3, 4, 5},
			{1, 2, 3, 4},
			{1, 2, 3}
		};
		System.out.println("输出的二维数组的结果如下：");
		for (int i = 0; i < arr.length ; i++) {
			for (int  j = 0; j < arr[i].length ; j++) {
				System.out.print(arr[i][j] + " ");
			}
			System.out.println(" ");
		}

	}
}

import java.util.Scanner;

public class array08 {
	public static void main(String[] args) {
		//二维数组的使用，动态数组赋值并输出
		Scanner lll = new Scanner(System.in);

		int arr[][];//声明二维数组
		arr = new int[2][3];//开辟数组空间，2行3列的二维数组。

		for (int i = 0; i < arr.length ; i++ ) {
			System.out.println("现在输入数组的第" + i + "行数据");
			for (int j = 0; j < arr[i].length ; j++ ) {
				System.out.println("输入第" + j + "列数据");
				int a = lll.nextInt();
				arr[i][j] = a;
			}
		}

		System.out.println("您输入的数组的结果如下：");

		for (int h = 0; h < arr.length ; h++ ) {
			for (int k = 0; k < arr[h].length ; k++ ) {
				System.out.print(arr[h][k] + " ");
			}
			System.out.println(" ");
		}
	}
}

import java.util.Scanner;

public class array09 {
	public static void main(String[] args) {
		//二维数组的使用，输出二维数组的第一行为1，第二行为两个2，第三行为3个3，以此类推。
		Scanner lll = new Scanner(System.in);

		System.out.println("您要输出几行：");
		int i = lll.nextInt();

		int[][] arr = new int[i][];

		for (int j = 0; j < arr.length ; j++ ) {

			arr[j] = new int[j + 1];//第0层有1个空间，第1层有两个空间。

			for (int k = 0; k < arr[j].length ; k++ ) {
				arr[j][k] = j + 1;//第一层的j等于0，所以要想每层都是对应层数的话，就需要进行加1
			}
		}

		System.out.println("您输入的数组的结果如下：");

		for (int m = 0; m < arr.length ; m++ ) {
			for (int n = 0; n < arr[m].length ; n++ ) {
				System.out.print(arr[m][n] + " ");
			}
			System.out.println(" ");
		}
	}
}

import java.util.Scanner;

public class array10 {
	public static void main(String[] args) {
		//二维数组的使用，动态数组赋值并输出
		Scanner lll = new Scanner(System.in);

		int arr[][];//声明二维数组
		arr = new int[3][3];//开辟数组空间，3行3列的二维数组

		for (int i = 0; i < arr.length ; i++ ) {
			System.out.println("现在输入数组的第" + i + "行数据");
			for (int j = 0; j < arr[i].length ; j++ ) {
				System.out.println("输入第" + j + "列数据");
				int a = lll.nextInt();
				arr[i][j] = a;
			}
		}

		int sum = 0;
		System.out.println("您输入的数组的结果如下：");

		for (int h = 0; h < arr.length ; h++ ) {
			for (int k = 0; k < arr[h].length ; k++ ) {
				System.out.print(arr[h][k] + " ");
				sum += arr[h][k];
			}
			System.out.println(" ");
		}
		System.out.println("您输入的数据总和为：" + sum);
	}
}

import java.util.Scanner;

public class YangHui {
	public static void main(String[] args) {
		//打印杨辉三角
		Scanner lll = new Scanner(System.in);

		System.out.println("您要输出几层杨辉三角：");

		int a = lll.nextInt();
		int[][] yanghui = new int[a][];
		for (int i = 0 ; i < yanghui.length ; i++) {
			yanghui[i] = new int[i + 1]; //开辟新的空间。
			for (int j = 0 ; j < yanghui[i].length ; j++ ) {
				if (j == 0 || j == yanghui[i].length - 1) {
					yanghui[i][j] = 1;
				} else {
					yanghui[i][j] = yanghui[i - 1][j - 1] + yanghui[i - 1][j];
				}
			}
		}
		System.out.println("输出结果如下：");
		for (int k = 0; k < yanghui.length ; k++ ) {
			for (int l = 0 ; l < yanghui[k].length ; l++) {
				System.out.print(yanghui[k][l] + " ");
			}
			System.out.println(" ");
		}
	}
}

import java.util.Scanner;

public class array11 {
	public static void main(String[] args) {
		//已知有一个升序的数组，要求插入一个元素，该数组的顺序依然是升序的，比如{10，12，45，90}，添加23后，数组为{10，12，23，45，90}
		Scanner lll = new Scanner(System.in);

		System.out.println("请先输入原始数组有几个数字（输入数字即可）：");
		int a = lll.nextInt();
		int[] arr = new int[a];
		int pt = 0;

		for (int i = 0 ; i < arr.length ; i++ ) {
			System.out.println("请输入第" + (i + 1) + "个数");
			arr[i] = lll.nextInt();
		}

		System.out.println("您输出数组的结果如下：");

		for (int j = 0; j < arr.length ; j++ ) {
			System.out.print(arr[j] + " ");
		}
		System.out.println(" ");
		//这里如果要对初始化的数组进行怕排序，可以使用冒泡排序进行。
		System.out.println("请输入您要插入的元素");

		int insert_element = lll.nextInt();
		int index = 0;

		for (int m = 0; m < arr.length; m++ ) {
			if (insert_element < arr[m]) {
				index = m;
				break;
			}else{
				index = arr.length;
			}
		}

		int[] b = new int[arr.length + 1];
		for (int n = 0; n < b.length ; n++) {
			if (n == index) {
				b[n] = insert_element;
			} else if (n > index) {
				b[n] = arr[n - 1];
			} else if (n < index) {
				b[n] = arr[n];
			}
		}

		for (int k = 0; k < b.length ; k++) {
			System.out.print(b[k] + " ");
		}

	}
}

public class array12 {
	public static void main(String[] args) {
		//随机生成10个整数（1-100）,保存到数组，并倒序打印以及求平均值，求最大值和最小值的下标，并查找里面是否含有8.
		int[] arr = new int[10];

		for (int i = 0; i < arr.length ; i++) {
			arr[i] = (int)(Math.random() * 100) + 1;
		}

		int sum = 0;
		int tag = 0;

		System.out.println("数组的正序输出如下：");
		for (int m = 0; m < arr.length ; m++ ) {
			System.out.print(arr[m] + "\t");
		}
		System.out.println(" ");
		
		System.out.println("数组的倒序输出如下：");
		for (int j = arr.length - 1; j >= 0  ; j--) {
			if (arr[j] == 8) {
				tag = 1;//若含有8的话，则置为1；
			}
			sum += arr[j];
			System.out.print(arr[j] + "\t");//"\t"相当与空4个空格，一个tab键。
		}
		System.out.println(" ");

		System.out.println("平均值为：" + (int)(sum / arr.length));

		int max = arr[0];
		int min = arr[0];
		int max_sub = 0;//最大值的下标
		int min_sub = 0;//最小值的下标

		for (int k = 0; k < arr.length ; k++) {
			if (arr[k] > max) {
				max_sub = k;
				max = arr[k];
			}
			if (arr[k] < min) {
				min_sub = k;
				min = arr[k];
			}
		}

		if (tag == 1) {
			System.out.println("是否含有8：" + "True");
		} else {
			System.out.println("是否含有8：" + "False");
		}

		System.out.println("最大值下标为：" + max_sub);
		System.out.println("最小值下标为：" + min_sub);
	}
}
二维数组的JVM内存布局

在这里插入图片描述

二维数组的使用细节
一维数组的声明方式有：int[ ] x 或者 int x[ ];
二维数组的声明方式有：int[][] y 或者int[] y[] 或者 int y[][]
二维数组实际上是由多个一维数组组成的，它的每个一维数组的长度可以相同也可以不相同。
比如：arr[][] = {{1,2},{1,2,3,4}}

布尔类型的数值未赋值之前默认为false。

UP的辰龙
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 如何调用数组_Java中数组的使用
weixin_42554042的博客
02-16 4790
1.声明数组1.1声明一维数组声明一维数组有下列两种格式：数组的元素类型 数组名字[ ];数组的元素类型[ ] 数组名字1.2声明二维数组声明二维数组有下列两种格式：数组的元素类型 数组名字[ ][ ];数组的元素类型[ ] [ ] 数组名字;例如：float boy[ ];char cat[ ][ ];Java数组声明注意以下两点内容：1.数组的元素类型可以是Java中...
Java基础语法——数组概念、数组内存图解（一个数组、二个数组）及二元数组的应用
zywcxz的博客
01-27 3204
Java基础语法——数组概念、数组内存图解（一个数组、二个数组）及二元数组的应用
Java数组的使用和方法
HAN&BLOG
07-22 4905
for循环是可以拿到数组下标的，for-each拿不到数组下标，所以for-each只能够全部遍历，无法对数组元素进行修改或进行操作.注意数组的每一元素都有其对应的下标，下标从0开始，想找到这个数组中的某个数据，是通过数组的下标来进行访问的。数组下标从0开始，范围是[0,arr.length),为左闭右开区间，或者[0,arr.length-1]尤其对于二维数组而言，无非就是一个一维数组，只不过该一维数组中的每一个元素是另一个。无论是二维数组，还是多维数组，它们本身就是一个一维数组。...
Java数组定义和使用（详解）
热门推荐
m0_52896041的博客
10-10 1万+
数组的定义和使用（超详解）
Java 数组的使用
一朵花花
08-15 4421
数组的定义 数组：可以看作相同类型元素的一个集合，且在内存中是一块连续的内存空间 注意： C语言中，数组的内存在栈上 在Java中，数组的内存在堆上 数组的创建及初始化： 1.数组的创建： 基本语法格式： T[ ] 数组名 = new T[N]； . ① T，即Type，表示：数组中存放元素的类 ② T[ ]， 表示：数组的类型 ③ N， 表示：数组的长度 举例： 创建一个可以容纳10个int类型元素的数组 int[] array1 = new int[10]; 创建一个可以容纳5个doub
Java中数组与集合的相互转换实现解析
08-25
Java中数组与集合的相互转换实现解析 Java中数组和集合是两种不同的数据结构，数组是一种固定长度的数据结构，而集合是一种可变长度的数据结构。它们之间的转换是非常重要的，在实际开发中经常会遇到这种情况。...
java中数组的定义及使用方法(推荐)
09-01
本文将深入探讨Java中数组的定义、使用方法以及相关知识点。 一、数组的定义 在Java中，数组是由相同类型的数据元素组成的集合。定义数组时，需要指定数据类型和数组的长度。数组长度在声明时必须是常量，不能在...
关于JAVA 数组的使用介绍
09-05
关于Java数组的使用，本文将深入探讨其特点、初始化方式以及一些常见的操作。在Java中，数组是一种重要的数据结构，它允许我们存储同一类型的多个元素。数组提供了高效的数据访问，但也有其局限性，尤其是在与Java...
Java中对象数组的使用方法详解
08-25
Java中对象数组的使用方法可以分为四种：静态方式、动态初始化方式、数组元素指向所定义的对象方式和创建对象数组，并分配对象空间方式。 首先，静态方式是指在声明数组变量时直接赋值，例如：`Person p1[] = { new...
Java中数组的定义与使用
最新发布
09-05
Java中数组的定义与使用
Java定义和调用方法操作数组
forbigcaiji的博客
07-29 284
几种操作数组的方法，另外补充增强for循环遍历数组
Java数组与调用方法
qq_44951853的博客
09-29 3412
自定义100个元素的数组，通过随机数生成各元素值 写三个方法：求最大值方法、求最小值方法、求平均数的方法并在main方法中调用。 代码如下： import java.util.Random; public class Suiji{ public static int Max(int a){ int max = a[0]; for(int i = 0;i<a.length;i++){...
Java中数组的使用(初学者必备)
m0_46813381的博客
04-15 2057
Java中数组的使用
weixin_49756100的博客
05-08 1081
今天给大家介绍的是Java中数组的基本使用，Java中的数组有一维数组和多维数组，今天主要讲一维数组和二维数组，多维数组可以在二维数组的基础上推导出用法。 1、数组的理解：数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。 2、数组的特点： （1数组是序排列的 （2数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 （3创建数组对象会在内存中开辟一整块连续的空间 （4数组的长度一旦确定，就不能修改。 一、 一
java输入一个数组调用方法_在java中使用最简单的方法打印数组内容？
weixin_29476545的博客
02-23 375
从Java 5开始，你可以将Arrays.toString(arr)或Arrays.deepToString(arr)用于数组中的数组。请注意，Object[]版本会调用.toString()数组中的每个对象。输出甚至按照您的要求进行修饰。例子：简单数组：String[] array = new String[] {"John", "Mary", "Bob"};System.out.println...
如何使用Java数组
Zhanhan15977的博客
12-16 967
使用数组四步走： 1.声明数组 2.分配空间 3.赋值 4.处理数据 1.声明数组：告诉计算机所用数据的类型是什么 2.分配空间：告诉计算机分配几个连续的空间 3.赋值：向分配的数组的格子里放数据 4.处理数据：对数据进行处理 一维数组的声明 一维数组的声明方式有两种 type[] arr-name; ...
java常见数组方法及实例
山鬼谣弋痕夕的博客
03-29 5316
介绍数组常用的方法和具体实例演示1、数组反转Array Collections.reverse(ArrayList) 将数组进行反转；2、通过 Collection 类的 Collection.max() 和 Collection.min() 方法来查找数组中的最大和最小值：下面举例演示反转和找最大最小值：import java.util.Arrays; import java.util.Coll...
java中数组形参的使用
05-12
在Java中，数组作为形参传递给方法时，实际上传递的是数组的引用，而不是数组的副本。因此，在方法中对数组进行更改会影响到原始数组。 以下是Java中使用数组形参的示例： 1. 传递一个整数数组作为形参： ``` public static void printArray(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } } ``` 2. 传递一个字符串数组作为形参： ``` public static void printArray(String[] arr) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } } ``` 可以看出，无论数组的类型是什么，都可以将其作为形参传递给方法。在方法中，我们可以使用传递的数组执行任意操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值