• 浅说一维数组以及遍历，length函数

    目录


    变量：存储数据的空间（装数据的容器），变量中只能存储一个数据
    数组：存储数据的空间（装数据的容器），数组中可以存储多个相同类型的数据

    数组的组成部分

    1. 标识符：数组的名称，取名原则与变量一样
    2. 数组元素：数组中存储的每一个数据称之为数组元素
    3. 元素下标：因为数组在内存中是连续的空间，所以会给数组里的元素按照顺序进行编号，编号从0开始，我们把这个编号叫下标(索引)
    4. 元素类型：描述的是数组中的元素类型

    声明数组

    数据类型[] 数组名; 或者 数据类型 数组名[];

    int[] nums ;
    String[] strs;

    分配空间

    告诉你我这个数组里能装多少个元素（数据）
    数组名 = new 数据类型[元素个数];

    nums = new int[5];
strs = new String[3];

    • 1
    • 2

    赋值

    将数据存储到数组中
    数组名[下标] = 数据;

    nums[0] = 99;
nums[1] = 83;
nums[2] = 78;
nums[3] = 88;
nums[4] = 66;
//nums[5] = 100; //ArrayIndexOutOfBoundsException:数组下标越界

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    ArrayIndexOutOfBoundsException:数组下标越界

    操作数据：通过数组名[下标]来操作数据
    S

    ystem.out.println(nums[0]);		//99
System.out.println(nums[1]); 	//83
nums[1]+=50;					//nums[1]=nums[1]+50;
System.out.println(nums[1]);

    • 1
    • 2
    • 3
    • 4

    声明数组、分配空间合并写

    数据类型[] 数组名 = new 数据类型[数组长度]; 或 数据类型 数组名[] = new 数据类型[数组长度]

    声明一个长度为3的double类型的数组

    double[] nums = new double[3];

    赋值,通过数组名[下标]给元素赋值，如果没有给元素赋值，系统会给元素赋予一个默认值

    nums[0] = 12.5;
    nums[1] = 22.5;

    输出数组里的每一个元素

    System.out.println(nums[0]);//12.5
    System.out.println(nums[1]);//22.5
    System.out.println(nums[2]);//0.0

    默认值

    char[] chs = new char[2]; System.out.println(chs[0]);
    //char类型数组元素默认值是空格

    boolean[] bools = new boolean[2];
    System.out.println(bools[0]);//false

    声明数组、分配空间、赋值合并写

    方法一：数据类型[] 数组名 = new 数据类型[ ]{数据1,数据2,…,数据n};
    方法二：数据类型 数组名[] = new 数据类型[ ]{数据1,数据2,…,数据n};
    注意：{}前面那个[ ]里不能写长度，写了就报错**

    声明一个长度为3的数组，并向数组里赋值 “hello” “java” “word”

    String[] strs = new String[] { "hello", "java", "word" };

    • 1

    操作数据

    System.out.println(strs[0]);
System.out.println(strs[1]);
System.out.println(strs[2]);

    • 1
    • 2
    • 3

    声明数组、分配空间、赋值合并写的简写方式

    方式一：数据类型[] 数组名 = {数据1,数据2,…,数据n};
    方式二：数据类型 数组名[] = {数据1,数据2,…,数据n};

    声明一个char类型的数组，并向数组里赋值 ‘a’ ‘b’ ‘c’ ‘d’

    char[] chs = { 'a','b','c','d'};
System.out.println(chs[0]);// a
//System.out.println(chs[6]);		//ArrayIndexOutOfBoundsException

    • 1
    • 2
    • 3

    练习1：声明一个长度为4的int类型的数组，使用键盘输入给数组每个元素赋值。遍历输出数组。

    package cn.bdqn.demo01;

import java.util.Scanner;

public class Demo04 {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		// 声明一个长度为4的int类型的数组
		int[] nums = new int[4];

		// 使用键盘输入给数组每个元素赋值
		// System.out.println("请输入数组里的第1个元素值：");
		// nums[0]=sc.nextInt();
		// System.out.println("请输入数组里的第2个元素值：");
		// nums[1]=sc.nextInt();
		// System.out.println("请输入数组里的第3个元素值：");
		// nums[2]=sc.nextInt();
		// System.out.println("请输入数组里的第4个元素值：");
		// nums[3]=sc.nextInt();
		
		//上述赋值操作，可以使用循环来实现
		for(int i =0;i<4;i++){
			System.out.println("请输入数组里的第"+(i+1)+"个元素值：");
			nums[i]=sc.nextInt();
		}
		
		System.out.println("数组中的元素依次是：");
		//输出数组里的每一个元素值
		// System.out.println(nums[0]);
		// System.out.println(nums[1]);
		// System.out.println(nums[2]);
		// System.out.println(nums[3]);
		
		//遍历数组：将数组中元素按照下标顺序依次输出
		for(int i = 0;i<4;i++){
			System.out.println("数组第"+(i+1)+"个元素是："+nums[i]);
		}

	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    遍历以及length的灵活运用

    遍历

    数据元素是怎样在内存中存放的？
    主要有2种存储方式：

    1、顺序存储，Random Access（Direct Access）：
    这种方式，相邻的数据元素存放于相邻的内存地址中，整块内存地址是连续的。可以根据元素的位置直接计算出内存地址，直接进行读取。读取一个特定位置元素的平均时间复杂度为O(1)。正常来说，只有基于数组实现的集合，才有这种特性。Java中以ArrayList为代表。

    2、链式存储，Sequential Access：
    这种方式，每一个数据元素，在内存中都不要求处于相邻的位置，每个数据元素包含它下一个元素的内存地址。不可以根据元素的位置直接计算出内存地址，只能按顺序读取元素。读取一个特定位置元素的平均时间复杂度为O(n)。主要以链表为代表。Java中以LinkedList为代表。

    每个遍历方法的实现原理是什么？

    1. 传统的for循环遍历，基于计数器的：
      遍历者自己在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后，停止。主要就是需要按元素的位置来读取元素。
    2. 迭代器遍历，Iterator：
      每一个具体实现的数据集合，一般都需要提供相应的Iterator。相比于传统for循环，Iterator取缔了显式的遍历计数器。所以基于顺序存储集合的Iterator可以直接按位置访问数据。而基于链式存储集合的Iterator，正常的实现，都是需要保存当前遍历的位置。然后根据当前位置来向前或者向后移动指针。
    3. foreach循环遍历：
      根据反编译的字节码可以发现，foreach内部也是采用了Iterator的方式实现，只不过Java编译器帮我们生成了这些代码。

    各遍历方式对于不同的存储方式，性能如何？

    1. 传统的for循环遍历，基于计数器的：
      因为是基于元素的位置，按位置读取。所以我们可以知道，对于顺序存储，因为读取特定位置元素的平均时间复杂度是O(1)，所以遍历整个集合的平均时间复杂度为O(n)。而对于链式存储，因为读取特定位置元素的平均时间复杂度是O(n)，所以遍历整个集合的平均时间复杂度为O(n2)（n的平方）。
      ArrayList按位置读取的代码：直接按元素位置读取。
    2. 迭代器遍历，Iterator：
      那么对于RandomAccess类型的集合来说，没有太多意义，反而因为一些额外的操作，还会增加额外的运行时间。但是对于Sequential
      Access的集合来说，就有很重大的意义了，因为Iterator内部维护了当前遍历的位置，所以每次遍历，读取下一个位置并不需要从集合的第一个元素开始查找，只要把指针向后移一位就行了，这样一来，遍历整个集合的时间复杂度就降低为O(n)；

    length的写法：
    数组名.length自动获取该数组的长度。

    遍历输出以下数组：

    package cn.bdqn.demo01;

public class Demo05 {

	public static void main(String[] args) {
		//遍历以下数组
		int[] nums = {11,23,45,6,78,96,88,73,62,12,10,36,55,99,45,66,19,64,13};
		
		//获取数组中元素的个数： 数组名.length;
		int length =nums.length;
		System.out.println("数组中元素个数："+length);

		//遍历数组
		for(int i =0;i<nums.length;i++){
			System.out.println(nums[i]);
		}
	
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    练习一：
    需求：
    1）根据班级人数来创建数组
    2）将每个学生的成绩存入到数组中
    3）求班级学生成绩总和
    4）求班级学生平均成绩

    package cn.bdqn.demo02;

import java.util.Scanner;

public class Demo01 {
	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		// 1）根据班级人数来创建数组:班级人数有多少个，数组的长度为就为多少
		System.out.println("请输入班级人数：");
		int num = sc.nextInt();

		// 根据班级人数来创建一个存放学生成绩的数组
		double[] scores = new double[num];

		// 声明一个变量sum用来累加所有学生的成绩
		double sum = 0;

		// 2）将每个学生的成绩存入到数组中
		for (int i = 0; i < scores.length; i++) {
			System.out.println("请输入第" + (i + 1) + "个学生的成绩：");
			scores[i] = sc.nextDouble();
			// 3）求班级学生成绩总和
			sum += scores[i];
		}

		// 4）求班级学生平均成绩
		double avg = sum / num;

		System.out.println("该班学生成绩总和：" + sum);
		System.out.println("该班学生平均成绩：" + avg);

	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    增强for循环

    语法结构：
    for(数据类型 变量名:数组名或集合名){
    对变量进行操作的代码
    }

    执行规律：
    将数组或者集合中的元素依次取出来存入到变量中，然后操作这个变量就等同于操作数组或者集合中的数据

    注意：增强for循环的执行效率比普通for循环高

    增强for循环遍历数组的运用：

    public static void main(String[] args) {

		int[] nums = { 11, 22, 33, 44, 55 };

		// 遍历数组
		System.out.println("-----普通for循环遍历数组-----");
		for (int i = 0; i < nums.length; i++) {
			System.out.println(nums[i]);
		}
		
		System.out.println("-----增强for循环遍历数组-----");
		for(int a : nums){
			System.out.println(a);
		}
		
		System.out.println("------------------------");
		for (int i : nums) {
			i+=100;
			System.out.println(i);
		}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    声明变量并将变量直接输出

    int num = 10;
    System.out.println(num); // 10

    数组是一个引用数据类型，直接输出数组名，输出的是数组在内存中的地址值

    int[] nums = { 11, 22, 33, 44, 55 };
    System.out.println(nums); //[I@4eafccbe

    练习二：
    有一个数列：8，4，2，1，23，344，12
    循环输出数列的值
    求数列中所有数值的和
    猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数

    package cn.bdqn.demo02;

import java.util.Scanner;

public class Demo04 {

	public static void main(String[] args) {
		
		int[] num = {8,4,2,1,23,344,12};
		
		//循环输出数列的值
		for (int i : num) {
			System.out.println(i);
		}
		
		//求数列中所有数值的
		//声明一个变量sum用来累加数组中所有元素之和
		int sum = 0;
		for (int i : num) {
			sum+=i;
		}
		System.out.println("数组中所有元素之和为："+sum);
		
		//猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数
		Scanner sc = new Scanner(System.in);
		System.out.println("请任意输入一个整数：");
		int guess = sc.nextInt();
		
		for (int i : num) {
			if(i==guess){
				System.out.println("数组中包含你猜测的数据");
				break;
			}
		}

	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    练习三：
    有一个数列：8，4，2，1，23，344，12
    猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数,如果包含此数，输出此数在数组中的位置(下标)，如果不包含此数，则输出数组中不包含此数

    package cn.bdqn.demo02;

import java.util.Scanner;

public class Demo05 {

	public static void main(String[] args) {

		int[] num = { 8, 4, 2, 1, 23, 344, 12 };

		Scanner sc = new Scanner(System.in);
		System.out.println("请任意输入一个整数：");
		int guess = sc.nextInt();
		
		//声明一个变量，用来统计比较的次数
		int count = 0;
		for (int i = 0; i < num.length; i++) {
			//判断你猜测的数据在不在数组
			if(guess!=num[i]){
				count++;
				if(count==num.length){
					System.out.println("你猜测的数据不在此数组中");
				}
			}else{
				System.out.println("你猜测的数据在此数组中，下标为："+i);
				//只要猜测的数据在数组中，后续就不需要再进行比较，退出整个循环
			}
		}
		
		
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    获取数组中的最大值或者最小值

    思想：
    1）先假设数组中的第1个元素（下标为0）为最大值
    2）依次将数组中后面的元素与这个最大值进行比较，如果比这个最大值还要大，取代它称为新的最大值
    3）比较到最后一个元素，就可以获取这个数组中的最大值

    package cn.bdqn.demo03;

public class Demo01 {

	public static void main(String[] args) {
		int[] nums = { 56, 60, 78, 42, 311, 88, 12 };
		// 1）先假设数组中的第1个元素（下标为0）为最大值
		int max = nums[0];

		// 2）依次将数组中后面的元素与这个最大值进行比较，如果比这个最大值还要大，取代它称为新的最大值
		// if(nums[1]>max){
		// max=nums[1];
		// }
		//
		// if(nums[2]>max){
		// max = nums[2];
		// }
		//
		// if(nums[3]>max){
		// max = nums[3];
		// }
		//
		// if(nums[4]>max){
		// max = nums[4];
		// }
		//
		// if(nums[5]>max){
		// max = nums[5];
		// }
		//
		// if(nums[6]>max){
		// max = nums[6];
		// }

		for (int i = 0; i < nums.length; i++) {
			if (nums[i] > max) {
				max = nums[i];
			}
		}

		System.out.println("数组中的最大值：" + max);

		// 获取最小值思路与获取最大值思路一样
		// 假设数组中第一个元素为最小值
		int min = nums[0];
		// 依次将数组中的元素取出来与这个最小值进行比较，如果元素值比这个最小值还小，就成为新的最小值，比较到最后一个元素，就可以得到数组中的最小值
		for (int i = 0; i < nums.length; i++) {
			if (nums[i] < min) {
				min = nums[i];
			}
		}
		System.out.println("数组中的最小值：" + min);
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56

    练习四：
    有一组学员的成绩{99，85，82，63， 60}，已经是按降序排列。 要增加一个学员的成绩，将它插入成绩序列，并保持降序

    思想：
    1）声明一个长度比原来数组长度大1的数组
    2）将原来数组里元素按照顺序存入到新的数组中
    3）使用Scanner类获取你要增加的学员成绩
    4）通过循环比较获取增加的学员成绩的插入位置
    5）从插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始，倒着移动）
    6）将要插入的成绩存储到插入位置

    package cn.bdqn.demo03;

import java.util.Scanner;

public class Demo02 {
	public static void main(String[] args) {

		// 创建Scanner类对象
		Scanner sc = new Scanner(System.in);

		int[] scores = { 99, 85, 82, 63, 60 };

		// 1）声明一个长度比原来数组长度大1的数组
		int[] newScores = new int[scores.length + 1];

		// 2）将原来数组里元素按照顺序存入到新的数组中
		// newScores[0]=scores[0];
		// newScores[1]=scores[1];
		// newScores[2]=scores[2];
		// newScores[3]=scores[3];
		// newScores[4]=scores[4];
		// 使用循环来实现上述赋值操作,赋值结束后，新数组元素是[99,85,82,63,60,0]
		for (int i = 0; i < scores.length; i++) {
			newScores[i] = scores[i];
		}

		System.out.println("插入学生成绩前的数组：");
		for (int i : newScores) {
			System.out.print(i + " ");
		}
		System.out.println();

		// 3）使用Scanner类获取你要增加的学员成绩
		System.out.println("请输入你要增加的学员成绩：");
		int insert = sc.nextInt();

		// 设置插入的成绩插入的位置，默认将其插入在数组最后位置
		int index = newScores.length - 1;
		// 4）通过循环比较获取增加的学员成绩的插入位置
		for (int i = 0; i < newScores.length; i++) {
			// 比较，如果插入的学员成绩比数组里的元素大，得到其插入位置
			if (insert > newScores[i]) {
				index = i;
				// 一旦得到插入成绩比数组元素大，就结束比较，后面不再进行比较
				break;
			}
		}

		// 5）从插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始，倒着移动）
		for (int i = newScores.length - 1; i > index; i--) {
			newScores[i] = newScores[i - 1];
		}

		// 6）将要插入的成绩存储到插入位置
		newScores[index] = insert;

		// 输出数组里的所有元素，看一下是否满足了需求
		System.out.println("插入学生成绩后的数组：");
		for (int i : newScores) {
			System.out.print(i + " ");
		}

	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66

    练习五：
    删除数组strs中的某个元素，删除完这个元素之后，后面的元素依次往前移动一位

    package cn.bdqn.demo03;

import java.util.Scanner;

public class Demo03 {

	public static void main(String[] args) {

		String[] strs = { "hello", "java", "html", "css", "JavaScript" };
		System.out.println("---元素删除前---");
		for (int i = 0; i < strs.length; i++) {
			System.out.print(strs[i] + " ");
		}
		System.out.println();
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你想删除的元素的下标(0-4):");
		int index = sc.nextInt();

		if (index == 4) {
			strs[4] = null;
		} else {
			for (int i = index; i < strs.length - 1; i++) {
				strs[i] = strs[i + 1];
			}
			// 元素往前移动之后，最后一个元素赋值为null
			strs[strs.length - 1] = null;
		}

		System.out.println("---元素删除后---");
		for (int i = 0; i < strs.length; i++) {
			System.out.print(strs[i] + " ");
		}
		System.out.println();

	}

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    总结

    数组常用写法：
    数据类型[] 数组名 = new 数据类型[数组长度];
    数据类型[] 数组名 = new 数据类型[ ]{数据1,数据2,…,数据n};
    数组是一个引用数据类型，直接输出数组名，输出的是数组在内存中的地址值
    遍历：通过for循环来遍历
    length函数：数组名.length自动获取该数组的长度。
    增强for循环：将数组或者集合中的元素依次取出来存入到变量中，然后操作这个变量就等同于操作数组或者集合中的数据

  • 相关阅读:
    05.智慧商城——路由前置守卫、首页动态渲染
    javaScript爬虫程序抓取评论
    猫吃什么罐头好？2023质量口碑好的猫罐头推荐！
    Java安全之Mojarra JSF反序列化
    聊聊线程池的预热
    前端加密解密 && crypto-js
    华为“天才少年” DIY 生日礼物：四个月打造能缝葡萄的机械臂！
    应用实践 | 10 亿数据秒级关联，货拉拉基于 Apache Doris 的 OLAP 体系演进
    uni-app 超详细教程（三）（从菜鸟到大佬）
    邀请加入团队
  • 原文地址：https://blog.csdn.net/qq_45734913/article/details/126760331