JavaSE 第 3 章 数组

已于 2022-04-12 20:37:38 修改
阅读量567 收藏
点赞数
分类专栏： 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python实现六大常见的排序算法
ShawDa's Blog
04-17 234
首先建立一个新文件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 239
JavaSE_第4章 数组 今日内容 数组概念 数组的声明和初始化 数组的索引 数组的长度 数组的遍历 数组内存 数组的相关算法 学习目标 理解数组作为容器的概念 掌握数组的声明和初始化 使用索引访问数组的元素 了解数组的内存图解 避免空指针和越界异常 掌握数组的遍历 掌握常见的数组算法 第四章 数组 4.1 容器概述 案例分析 现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有50名员工，用前面所学的知识，程序首先需要声明50个变量来分别记住每位员工的工
java 查找排序_Java使用二分法进行查找和排序的示例
weixin_39842475的博客
02-12 193
//递归二分查找 初始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 = (...
binarySearch方法
weixin_41676972的博客
02-28 371
binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要，binarySearch()有两种参数类型注：此法为二分搜索法，故查询前需要用sort()方法将数组排序，如果数组没有排序，则结果是不确定的，另外如果数组中含有多个指定值的元素，则无法保证找到的是哪一个。⑴.binarySearch(object[ ], object key);如果key在数组中，则返回搜索值的索...
二分法查找 JAVA实现
学习学习再学习
05-18 416
算法定义：假设数据是按升序排序的，对于给定值x，从序列的中间位置开始比较，如果当前位置值等于x，则查找成功；若x小于当前位置值，则在数列的前半段中查找；若x大于当前位置的值则在数列的后半段中继续查找，直到找到为止。 适用场景：当数据量很大时，数据有序但是不重复； java代码如下所示（直接取用BinarySearch即可测试）： package test; import java.util
JavaSE 第四章 数组
技术小白
01-16 370
1、数组的概述 在执行程序的过程中，经常需要存储大量的数据，例如，假设需要读取100个数，计它们的平均值，然 后找出有多少个数大于平均值。首先，程序读入这些书并且计算它们的平均值，然后将每个数与平均值 进行比较判断它是否大于平均值。为了完成这个任务，必须将全部的数据存储到变量中。必须声明100 个变量，并且重复书写100次几乎完全相同的代码。这样编写程序的方式似乎是不太现实的，那么该如 何解决这个问题呢？ Java和许多高级语言都提供了一种称作数据（array）的数据结构，可以用它来存储一个元素个数固定
javaSE第三章数组
WoWBOOM的博客
07-17 163
数组的一些基本知识
JavaSE第四章 数组Array
qq_37079157的博客
11-07 191
文章目录4 第四章数组4.1 概念4.2 数组的创建4.2.1 声明方式4.2.2 数组对象的默认值4.2.3 动态创建数组4.2.4 静态创建数组4.2.5 数组的长度4.3 数组的访问4.4 数组的迭代4.4.1 fori普通循环4.4.2 foreach增强循环4.5 排序4.5.1 比较类排序交换排序冒泡排序（稳定）快速排序插入排序简单插入排序（稳定）希尔排序选择排序简单选择排序堆排序归并排序（稳定）二路归并排序多路归并排序4.5.2 非比较类排序计数排序桶排序基数排序 4 第四章数组 4.1 概念
javaSE代码实例
06-21
第1章　初识Java　3 1.1　Java简介　3 1.1.1　Java的不同平台　3 1.1.2　Java发展的历程　3 1.1.3　Java的特点　4 1.2　安装开发工具包　5 1.2.1　下载JDK　5 1.2.2　安装JDK　6 1.2.3　安装后Java目录的解读　7 1.3...
写给大忙人看的JavaSE8
01-12
第2章给出了流的完整概述：第3 章给出了使用lambda表达式设计库的有效技巧；第4 章介绍了JavaFX：第5章详细介绍了Java新增 的日期／时间API；第6章介绍了原子计数器、并发哈 希映射、并行数组操作等特性中的改进；第...
course-JavaSE-Android:Java与移动智能设备开发方向，《JavaSE》课程仓库
04-28
course-JavaSE-Android 本课程是软件工程专业学生移动智能设备方向的专业基础课，内容涵盖Java面向对象...第3章 数组 数组概述、一维数组、Arrays类、二维数组 第4章 类和对象 类和对象概述、类的成员方法、垃圾回收机
java成长之路（2020.3.1）
12-22
文章目录java基础学习大纲每章小结：第一章：第二章：第三章：第四章：第五章：第六章：第七章：第八章：第九章：第十章：第十一章：第十二章： 详情见下图： 每章小结： 第一章： 所有的编程语言的最终目的都是...
写给大忙人看的Java SE 8
03-29
第3章给出了使用lambda表达式设计库的有效技巧；第4章介绍了JavaFX；第5章详细介绍了Java新增的日期/时间API；第6章介绍了原子计数器、并发哈希映射、并行数组操作等特性中的改进；第7章介绍了如何在Java虚拟机上...
jar包增量更新分析
junlaiyan的专栏
05-16 242
借助jdeps分析出jar包的增量文件
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
最新发布
qq_29022265的博客
05-19 797
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
java实现拼图小游戏
monkey108的博客
05-16 607
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 891
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
javase数组对象
10-14
JavaSE中的数组对象是一种特殊的对象，它可以存储固定数量的同类型元素。数组对象在创建时需要指定元素类型和数组长度，一旦创建后，数组长度就不能再改变了。 例如，创建一个包含5个整数的数组对象可以使用以下...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值