JavaSE 第 3 章 数组

已于 2022-04-12 20:37:38 修改
阅读量632 收藏
点赞数
分类专栏： JavaSE 文章标签： java
于 2022-03-27 10:05:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Serinaldo/article/details/123768734
版权

1.一维数组的使用

1）一维数组的声明和初始化

2）如何调用数组的指定位置的元素

3）如何获取数组的长度

4）如何遍历数组

public class ArrayTest {

	public static void main(String[] args) {
		
		//一维数组的声明和初始化；
		int[] ids;
		ids = new int[]{1001,1002,1003,1004};//1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行
		
		//也是正确的：
		int[] ide = {1,2,3,4,5};//类型推断
		int ida[] = {1,2,3,4,5};//中括号位置可以更改
		
		//1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];

		//总结:数组一旦初始化完成，其长度就确定了
		
		//2.如何调用数组的指定位置的元素:通过角标（索引）的方式调用
		names[0] = "Vlahovic";
		names[1] = "Pogba";
		names[2] = "Mbappe";
		names[3] = "Halland";
		names[4] = "Cristiano";
		
		//3.如何获取数组的长度。属性：length
		System.out.println(names.length);
		System.out.println(ids.length);
		
		//4.如何遍历数组元素
		int i;
		for(i = 0;i < names.length;i++)
		{
			System.out.println(names[i]);
		}
		
		
	}

}

5）数组元素的默认初始化值

public class ArrayTest1 {

	public static void main(String[] args) {
		
		//5.数组元素的默认初始化值
		int i;
		int[] arr = new int[4];
		
		for(i = 0;i < arr.length;i++)
		{
			System.out.println(arr[i]);
		}
		
		short[] arr1 = new short[4];
		for(i = 0;i < arr1.length;i++)
		{
			System.out.println(arr1[i]);
		}//数组元素是整形：0
		
		float[] arr2 = new float[4];
		for(i = 0;i < arr2.length;i++)
		{
			System.out.println(arr2[i]);
		}//数组元素为浮点型：0.0
		
		char[] arr3 = new char[4];
		for(i = 0;i < arr3.length;i++)
		{
			System.out.println("----" + arr3[i] + "----");
		}//数组元素为字符型：类似于空格的符号
		
		boolean[] arr4 = new boolean[4];
		for(i = 0;i < arr4.length;i++)
		{
			System.out.println(arr4[i]);
		}//数组元素为boolean：false
		
		String[] arr5 = new String[4]; 
		for(i = 0;i < arr5.length;i++)
		{
			System.out.println(arr5[i]);
		}//数组元素为引用数据类型：null
		
		
		
		
		
		
	}

}

6）数组的内存解析

数组地址在栈空间，赋值留在堆空间内

TEST2:

import java.util.Scanner;

public class FindGrade {

	public static void main(String[] args) {
		
		Scanner scanf_s = new Scanner(System.in);
		
		System.out.println("请输入学生人数：");
		
		int num1 = scanf_s.nextInt();
		int[] score = new int[num1];
		char[] grade = new char[num1];
		
		int i, maxScore = 0;
		
		System.out.println("请输入" + num1 + "个学生的成绩：");
		
		for(i = 0;i < score.length;i++)
		{
			score[i] = scanf_s.nextInt();
		}
		
		for(i = 0;i < score.length;i++)
		{
			if(maxScore < score[i])
			{
				maxScore = score[i];
			}
		}
		System.out.println("最高分是" + maxScore);
		
		for(i = 0;i < score.length;i++)
		{
			if(score[i] >= (maxScore - 10))
			{
				grade[i] = 'A';
			}else if(score[i] >= (maxScore -20))
			{
				grade[i] = 'B';
			}else if(score[i] >= (maxScore - 30))
			{
				grade[i] = 'C';
			}else
			{
				grade[i] = 'D';
			}
		}
		
		for(i = 0;i < score.length;i++)
		{
			System.out.println("student " + i + " score is " + score[i] + " grade is " + grade[i]);
		}
	}

}

2.二维数组的使用（数组的元素又是数组）

1）二维数组的声明和初始化

2）如何调用数组的指定位置的元素

3）如何获取数组的长度

4）如何遍历数组

5）数组元素的默认初始化值

package com.atguigu.java;

public class ArrayTest3 {
	public static void main(String[] args) {
		
		//数组元素的默认初始化值
		int[][] arr = new int[4][3];
		System.out.println(arr[0]);//地址值
		System.out.println(arr[0][0]);
        
        int[][] arr1 = new int[4][];
        System.out.println(arr1[4]);//null
	}

}

6）数组的内存解析

public class ArrayTest2 {
	public static void main(String[] args) {
		//1.二维数组的声明和初始化
		int[] arr = new int[]{1,2,3};//一维数组
		
		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5,6}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
		
		int[] arr4[] = new int[][]{{1,2,3},{4,5},{6,7,8}};
		
		//2.如何调用数组指定位置的元素
		System.out.println(arr1[0][1]);//2
		System.out.println(arr2[1][1]);//null
		
		arr3[1] = new String[4];//
		System.out.println(arr3[1][0]);
		
		//3.获取数组的长度
		System.out.println(arr4.length);//3
		System.out.println(arr4[1].length);//2
		System.out.println();
		
		//4.如何遍历2维数组
		int i, j;
		for(i = 0;i < arr4.length;i++)
		{
			for(j = 0;j < arr4[i].length;j++)
			{
				System.out.println(arr4[i][j]);
			}
		}
	}

}

打印杨辉三角：

import java.util.Scanner;

public class YanghuiTriangle {
	public static void main(String[] args) {
		
		Scanner scanf_s  = new Scanner(System.in);
		
		System.out.println("请输入要打印的杨辉三角的行数：");
		int n = scanf_s.nextInt();
		int[][] yanghui = new int[n][n];
		int i, j;
		
		for(i = 0;i < n;i++)
		{
			yanghui[i][0] = 1;
			yanghui[i][i] = 1;
		}
		
		for(i = 2;i < n;i++)
		{
			for(j = 1;j <= i - 1;j++)
			{
				yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
			}
		}
		
		for(i = 0;i < n;i++)
		{
			for(j = 0;j <= i;j++)
			{
				System.out.print(yanghui[i][j] + " ");
			}
			System.out.println();
		}
		
	}

}

3.数组中涉及到的常用算法

1.数组元素的赋值

package com.atguigu.test;
/*
 * 获取一个充满1-30的随机数的数组
 */
public class SetValue {
	public static void main(String[] args) {
		
		int[] arr = new int[6];
		int i, j;
		
		for(i = 0;i < arr.length;i++)
		{
			arr[i] = (int) (Math.random() * 30) + 1;
			
			for(j = 0;j < i;j++)
			{
				if(arr[j] == arr[i])
				{
					i--;
					break;
				}
			}
		}
		
		for(i = 0;i < arr.length;i++)
		{
			System.out.println(arr[i]);
		}
	}
}

2.数组的复制、反转、查找

package com.atguigu.exer;


public class ArrayCopy {
	public static void main(String[] args) {
		
		
		/*
		 * 实现数组的复制
		 * */
		
		
		int[] array1 ,array2;
		array1 = new int[]{1,3,5,7,8};
		
		array2 = new int[array1.length];
		
		for(int i = 0;i < array1.length;i++)
		{
			array2[i] = array1[i];
		}
		//输出
		for(int i = 0;i < array1.length;i++)
		{
			System.out.println(array2[i]);
		}
		
		System.out.println();
		
		
		/*
		 * 数组的反转
		 * */
		
		for(int i = 0;i < array1.length / 2;i++)//终止条件为array1.length / 2,防止反转两遍
		{
			int temp = array1[i];
			array1[i] = array1[array1.length - i - 1];
			array1[array1.length - i - 1] = temp;
		}
		//输出
		for(int i = 0;i < array1.length;i++)
		{
			System.out.println(array1[i]);
		}
		System.out.println();
		
		
		/*
		 * 线性查找
		 * 
		 * */
		
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		String dest = "BB";
		
		boolean isFlag = true;
		
		for(int i = 0;i <arr.length;i++)
		{
			if(dest.equals(arr[i]))
			{
			System.out.println("找到了指定的元素，位置为" + i);
			isFlag = false;
			break;
			}
			
		}
		
		if(isFlag)
		{
			System.out.println("很遗憾，没有找到哦！");
		}
		System.out.println();
		
		/*
		 * 二分法查找
		 * 前提：所要查找的数组必须有序
		 * */
		
		int[] arr2 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
		int dest1 = -34;
		int head = 0;//初始首索引
		int end = arr2.length - 1;
		
		boolean isFlag1 = true;
		
		while(head <= end)
		{
			int middle = (head + end)/ 2;
			
			if(dest1 == arr2[middle])
			{
				System.out.println("找到了指定的元素，位置为" + middle);
				isFlag1 = false;
				break;
			}
			else if(arr2[middle] > dest1)
			{
				end =  middle - 1;
			}
			else
			{
				head = middle + 1;
			}
			
		}
		
		if(isFlag1)
		{
			System.out.println("很遗憾，没有找到哦！");
		}
		System.out.println();
		
		/*
		 * 
		 * 排序算法
		 * 
		 * */
		
		
		
	}

}

3.冒泡排序和快速排序

冒泡排序

package com.atguigu.test;

/*
 * 数组的冒泡排序的实现
 * 
 * */

public class BubbleSortTest {
	public static void main(String[] args) {
		
		int[] array1 = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};
		
		//冒泡排序
		int test;
		
		for(int i = 0;i < array1.length - 1;i++)
		{
			for(int j = 0;j < array1.length - i - 1;j++)
			{
				if(array1[j] > array1[j + 1])
				{
					test = array1[j];
					array1[j] = array1[j + 1];
					array1[j + 1] = test;
				}
			}
		}
		
		
		for(int i = 0;i < array1.length;i++)
		{
			System.out.print(array1[i] + "\t");
		}
		
	}

}

快速排序

package com.atguigu.java;

/**
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
 * 则分别对这两部分继续进行排序，直到整个序列有序。
 * @author shkstart
 * 2018-12-17
 */
public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

4.Arrays工具类的使用

1

boolean equals(int[] a,int[] b)

判断两个数组是否相等

2

String to String(int[], a)

输出数组信息

3

void fill(int[] a, int val)

将指定值填充到数组当中

4

void sort(int[] a)

对数组进行排序

5

int binarySearch(int[] a,int key)

对排序后的数组进行二分法检索指定的值

package com.atguigu.test;

import java.util.Arrays;

public class ArraysTest {
	public static void main(String[] args) {
		
		
		//1	boolean equals(int[] a,int[] b)	判断两个数组是否相等
		
		int[] arr1 = new int[]{1, 2, 3, 4};
		int[] arr2 = new int[]{1, 3, 2, 4};
		
		boolean isEquals = Arrays.equals(arr1, arr2);
		
		System.out.println(isEquals);
		//2	String to String(int[], a)	输出数组信息
		System.out.println(Arrays.toString(arr1));
		
		//3	void fill(int[] a, int val)	将指定值填充到数组当中
		Arrays.fill(arr1, 10);
		System.out.println(Arrays.toString(arr1));
		
		//4	void sort(int[] a)	对数组进行排序
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5	int binarySearch(int[] a,int key)	对排序后的数组进行二分法检索指定的值
		int[] arr3 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
		int index = Arrays.binarySearch(arr3, 2);
		System.out.println(index);//index若返回一个负数，则没找到
		
		
	}

}

5.数组中常见异常

package com.atguigu.test;
/**
 * 数组常见异常
 * 1.数组角标越界异常：ArrayIndexOutOfBoundsException
 * 
 * 2.空指针异常：NullPointerException
 * 
 * */
public class ArrayExceptionTest {
	public static void main(String[] args) {
		
		//1.角标越界
		
		int[] arr = new int[]{1, 2, 3, 4, 5};
		//System.out.println(arr[5]);
		//System.out.println(arr[-2]);
		
		
		/*2.空指针异常
		//情况一：
		int[] arr1 = new int[]{1,2,3};
		arr1 = null;
		System.out.println(arr1[0]);
		
		//情况二：
		int[][] arr2 = new int[4][];
		System.out.println(arr2[0]);//输出为null:堆中一维数组已经分配好内存空间    且    栈中内存指向堆空间
		System.out.println(arr2[0][0]);//空指针异常，二位数组尚未分配内存空间，一维数组无指针指向二维数组
		*/
		//情况三：
		String[] arr3 = new String[]{"AA","BB","CC"};
		arr3[0] = null;
		System.out.println(arr3.toString());//对象是null
	}

}
Cristiangodz
关注
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
java 查找排序_Java使用二分法进行查找和排序的示例
weixin_39842475的博客
02-12 228
//递归二分查找 初始start=0, end = array.length - 1static int binarySearch4Recursion(int[] array, int data, int start, int end) {int mid = -1;System.out.println("查找次数");if (start > end) {return mid;}mid = (...
二分法查找 JAVA实现
学习学习再学习
05-18 439
算法定义：假设数据是按升序排序的，对于给定值x，从序列的中间位置开始比较，如果当前位置值等于x，则查找成功；若x小于当前位置值，则在数列的前半段中查找；若x大于当前位置的值则在数列的后半段中继续查找，直到找到为止。 适用场景：当数据量很大时，数据有序但是不重复； java代码如下所示（直接取用BinarySearch即可测试）： package test; import java.util
binarySearch方法
weixin_41676972的博客
02-28 411
binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要，binarySearch()有两种参数类型注：此法为二分搜索法，故查询前需要用sort()方法将数组排序，如果数组没有排序，则结果是不确定的，另外如果数组中含有多个指定值的元素，则无法保证找到的是哪一个。⑴.binarySearch(object[ ], object key);如果key在数组中，则返回搜索值的索...
Python实现六大常见的排序算法
ShawDa's Blog
04-17 283
首先建立一个新文件random_list.py用来随机生成整数列表，代码如下： # -*- coding:utf-8 -*- __author__ = 'ShawDa' import random def random_int_list(start, stop, length): start, stop = ( int(start), int(stop)) if st...
JavaSE第4章数组
m0_56593901的博客
05-13 326
JavaSE_第4章 数组 今日内容 数组概念 数组的声明和初始化 数组的索引 数组的长度 数组的遍历 数组内存 数组的相关算法 学习目标 理解数组作为容器的概念 掌握数组的声明和初始化 使用索引访问数组的元素 了解数组的内存图解 避免空指针和越界异常 掌握数组的遍历 掌握常见的数组算法 第四章 数组 4.1 容器概述 案例分析 现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有50名员工，用前面所学的知识，程序首先需要声明50个变量来分别记住每位员工的工
javaSE第三章_数组 (循环嵌套,方法,数组)
SDWESCES的博客
03-30 1827
循环嵌套 印出九九乘法表 public class ChengFaBiaoDemo{ public static void main(String[] args){ int i,j; for(i=1;i<=9;i++){ for (j=1;j<=i;j++){ System.out.print(j + "*" + i + "=" + i * j); System.out
javaSE第四章_数组 (练习)五子棋游戏的代码实现
SDWESCES的博客
04-17 1232
文章目录需求：思路：代码实现：运行结果 需求： 用二维数组,实现五子棋功能.： 在控制台通过Scanner输入黑白棋坐标),使用实心五角星和空心五角星表示黑白棋子. 输入后重新输出棋盘如下图: 黑白棋依次重复输入下棋,当任意一方构成五子相连时提示胜利,结束游戏. 思路： 使用二维数组定义棋盘 //开始游戏 startGame(); //判断输赢 isWin() //横向 qp[i][j]==black&a
JavaSE：第3章 数组
Alu_em的博客
08-07 502
文章目录数组3.1 数组的概述✔ 数组的常见概念✔ 数组的分类：3.2 一维数组的使用✔ 声明✔ 初始化???? 动态初始化：???? 静态初始化：✔ 数组元素的引用✔ 数组元素的默认初始化值✔ 创建基本数据类型数组 (1)✔ 创建基本数据类型数组 (2)✔ 创建基本数据类型数组 (3)✔ 内存的简化结构✔ 一维数组的内存解析✔ 一维数组的使用：例题3.3 多维数组的使用✔ （动态初始化）✔ （静态初始化）✔ 初始化使用✔ 二维数组的内存解析???? 二维数组练习：杨辉三角???? 二维数
【JavaSE 知识框架】03 数组
woailuo8214的博客
11-09 441
【数组】 ｛数组的概述｝｛一维数组的使用｝｛多维数组的使用｝ ｛数组中涉及到的常见算法｝｛算法｝ ｛数组元素的排序算法｝｛Arrays工具类｝ ｛数组使用中常见的异常｝｛Eclipse教程链接｝
JAVASE第三章(数组)
qq_52173163的博客
04-08 551
文章目录前言一、数组的基本概念及作用二、数组的创建1.数组的声明的两种方式2.数组创建的三种方式3.静态数组和动态数组三、数组的访问与迭代1.数组迭代的两种方式四、数组排序1.冒泡排序五、习题 前言 数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。 Java 语言中提供的数组是用来存储固定大小的同类型元素。 一、数组的基本概念及作用 • 1.数组是相同数据类型元素的集合 • 2.数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类
Mybatis
庸不易的博客
11-15 804
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 938
Rest请求处理
java加锁问题详解
qq_74056922的博客
11-14 769
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
什么是面向对象编程？什么是面向过程编程？
m0_70208894的博客
11-15 519
不同的编程范式适用于不同的场景，选择合适的范式可以提高代码的可维护性、可读性和效率。Java 和 Go 的选择反映了不同的设计哲学，Java 更加注重封装和对象的使用，而 Go 更加简洁，强调过程和函数的使用。
HashMap源码分析下
L25000的专栏
11-16 621
如果这个cap刚好是2的幂次方呢，即4,8,16,32,64等这样的，这样的数已经满足条件了，再减去1，把数变成3,7,31,63。，即hash值的第5为是1，这样在扩容到32后，取索引得出来的结果就和16的不一样了，索引位置比oldCap大了一个oldCap值；,求余数，n是一个2的幂次方数，减去1，即后面全是1，前面全是0，与上这个hash，只能保证经过运算，结果都会在。，即hash值的第5为是0，这样在扩容到32后，取索引得出来的结果还是和16的一样；cap=1，2的0次方就等于1，返回的是就是4。
BP新增页签增强
BinGeneral的博客
11-15 991
以上就是BP新增页签的介绍，希望对您有所帮助。在总结过程中，该篇文档给予了极大的帮助和借鉴。
Struts扫盲
spy47_的博客
11-14 1323
这里的struts是struts1。以本文记录我的那些复习JavaEE的痛苦并快乐的晚上。
vmWare虚拟环境centos7安装Hadoop 伪分布式实践
最新发布
keep_learn的专栏
11-17 655
背景：近期在研发大数据中台，需要研究Hadoop hive 的各种特性，需要搭建一个Hadoop的虚拟环境，本来想着使用dock ，但突然发现docker 公共仓库的镜像 被XX 了，无奈重新使用vm 搭建虚拟机。大概经历了6个小时完成hadoop 3.3.6 环境的搭建，分享步骤给大家，需要搭建好的虚拟机镜像私信联系，提供百度网盘下载链接。(需要请一杯奶茶)。操作系统版本：centos 7本次实践实践2024年，未来2年内有效。
基于java的二手图书交易系统
源码好优多
11-16 113
项目编号：springbootA069现代二手图书交易系统综合了共享信息、电子化、智能化等多种技术，对二手图书交易系统的多个流程了实现整合。信息化的二手图书交易系统是由多个分布式子系统组成的，各分布式子系统既可以完全独立运作，又有一定的联系。只有提高二手图书交易系统的各环节、各子系统的信息化水平，才能提高整个二手图书交易系统的运行效率。使用网络化智能分析技术后，可以实时的获取图书信息或用户需求等数据，对海量的数据进行过滤和分析，就能得到有价值的信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值