文章目录
- 参考资料
- 1.数组的概述
- 2. 一维数组的使用
- 2.1 声明
- 2.2 初始化
- 2.3 数组元素的引用
- 2.4 数组元素的默认初始化值
- 2.5 内存的简化结构
- 2.6 练习
- 3. 多维数组的使用
- 4. 数组中设计的常见算法
- 4.1 基本操作示例
- 4.2 数组的复制、反转、二分查找
- 5. 数组元素的排序算法
- 5.1 十大内部排序算法
- 5.2 冒泡排序 （Bubble Sort）
- 5.3 快速排序（Quick Sort）
- 6. Arrays 工具类的使用
- 7. 数组使用中的常见异常
- 8. 数组的一些练习
参考资料
1.数组的概述
- 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
- 数组的相关概念：
数组名
元素
角标、下标、索引：从0开始
数组的长度：元素的个数- 数组的特点：
2. 一维数组的使用
2.1 声明
2.2 初始化
2.3 数组元素的引用
2.4 数组元素的默认初始化值
数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。
对于基本数据类型，默认初始化值各有不同；
对于引用数据类型，默认初始化值null。
2.5 内存的简化结构
- 栈空间（stack），连续的存储空间，遵循后进先出的原则，用于存放局部变量。
- 堆空间（heap），不连续的空间，用于存放new出的对象，或者说是类的实例。
- 方法区（method），方法区在堆空间内，用于存放：
类的代码信息；
静态变量和方法；
常量池（字符串敞亮等，具有共享机制）。- Java中除了基本数据类型，其他的均是引用类型，包括类、数组等等。
- 变量初始化
成员变量可不初始化，系统会自动初始化；
局部变量必须由程序员显式初始化，系统不会自动初始化。
通俗地说：
- 栈：
基本数据类型直接在栈中分配空间，局部变量（在方法代码段中定义的变量）也在栈中直接分配空间，当局部变量所在方法执行完成之后该空间便立刻被JVM回收，还有一种是引用数据类型，即我们通常所说的需要用关键字new创建出来的对象所对应的引用也是在栈空间中，此时，JVM在栈空间中给对象引用分配了一个地址空间（相当于一个门牌号，通过这个门牌号就可以找到你家），在堆空间中给该引用的对象分配一个空间，栈空间中的地址引用指向了堆空间中的对象区（通过门牌号找住址）；- 堆：
一般用来存放用关键字new出来的数据。
2.6 练习
import java.util.Scanner;
public class ArrayTest {
private static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
System.out.print("please input the number of students: ");
int n;
for (;;) {
String str = readKeyBoard(4);
try {
n = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("input wrong, please input again:");
}
}
int[] grades = new int[n];
System.out.println("please input the "+n+" students'grades, respectively:");
for (int i = 0; i < grades.length; i++) {
for (;;) {
String str = readKeyBoard(4);
try {
grades[i] = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("input wrong, please input again:");
}
}
}
int max = 0;
for (int i : grades) {
if (i>max){
max = i;
}
}
System.out.println("the highest score is: "+max);
for (int i = 0; i < grades.length; i++){
if (grades[i]>max-10){
System.out.println("student "+i+" score is "+grades[i]+"\t grade is " +"A");
}
else if (grades[i] > max - 20) {
System.out.println("student " + i + " score is " + grades[i] + "\t grade is " + "B");
}
else if (grades[i] > max - 30) {
System.out.println("student " + i + " score is " + grades[i] + "\t grade is " + "C");
}
else{
System.out.println("student " + i + " score is " + grades[i] + "\t grade is " + "D");
}
}
}
private static String readKeyBoard(int limit) {
String line = "";
while (scanner.hasNext()) {
line = scanner.nextLine();
if (line.length() < 1 || line.length() > limit) {
System.out.print("Input length (not greater than" + limit + ")input wrong, please input again:");
continue;
}
break;
}
return line;
}
}3. 多维数组的使用
把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格，像下图Excel中的表格一样。
对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。
针对于初始化方式而：比如：
int[][] arr = new int[4][];外层元素的初始化值为：null；内层元素的初始化值为：不能调用，否则报错。
访问所有的数组元素可以用for-each循环：
public class MultiArrayTest {
public static void main(String[] args) {
int[][] arr = new int[][] { { 3, 8, 2 }, { 2, 7 }, { 9, 0, 1, 6 } };
for (int[] is : arr) {
for (int is2 : is) {
System.out.println(is2);
}
}
}
}
练习：使用二维数组打印一个 10 行杨辉三角。
/*
* 【提示】
* 1. 第一行有 1 个元素, 第 n 行有 n 个元素
* 2. 每一行的第一个元素和最后一个元素都是 1
* 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。
* 即：yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
*/
public static void yangHuiTriangle(){
int[][] yang_hui = new int[10][10];
yang_hui[0][0] = 1;
yang_hui[1][0] = 1;
yang_hui[1][1] = 1;
System.out.println(yang_hui[0][0] + "\t");
System.out.println(yang_hui[1][0] + "\t"+ yang_hui[1][1]);
for(int i = 2;i<10;i++){
for(int j =0;j<=i;j++){
if(j==0 || j==i)yang_hui[i][j]=1;
else{
yang_hui[i][j] = yang_hui[i-1][j-1]+yang_hui[i-1][j];
}
System.out.print(yang_hui[i][j]+"\t");
}
System.out.println();
}
}官方实现代码:
public class ArrayEver2 {
public static void main(String[] args) {
//1.声明并初始化二维数组
int[][] arr = new int[10][];
//2.给数组的元素赋值，遍历二维数组
for(int i = 0;i < arr.length;i++){
arr[i] = new int[i+1];
//2.1 给首末元素赋值
arr[i][0]=arr[i][i]=1;
//2.2 给每行的非首末元素赋值
// if(i > 1){
for(int j = 1;j < arr[i].length-1;j++){
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
// }
}
// 3.遍历数组
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();
}
}
}练习：创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求
元素的值各不相同
public static void testArray(){
/*
* 创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，
* 且是随机赋值。同时，要求元素的值各不相同
*/
int [] arr = new int[6];
for(int i =0;i<arr.length;i++){
arr[i] = (int)(Math.random()*30)+1;
for(int j = 0;j<i;j++){
while(arr[i]==arr[j]){
arr[i]= (int)(Math.random() * 30) + 1;
}
}
}
for(int i =0;i<arr.length;i++){
System.out.println(arr[i]);
}
}官方代码
//此题只做了解，初学不必精通。
public class ArrayEver3 {
public static void main(String[] args) {
// 方式一：
// int[] arr = new int[6];
// for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31)
// arr[i] = (int) (Math.random() * 30) + 1;
//
// boolean flag = false;
// while (true) {
// for (int j = 0; j < i; j++) {
// if (arr[i] == arr[j]) {
// flag = true;
// break;
// }
// }
// if (flag) {
// arr[i] = (int) (Math.random() * 30) + 1;
// flag = false;
// continue;
// }
// break;
// }
// }
//
// for (int i = 0; i < arr.length; i++) {
// System.out.println(arr[i]);
// }
// 方式二：
int[] arr2 = new int[6];
for (int i = 0; i < arr2.length; i++) {// [0,1) [0,30) [1,31)
arr2[i] = (int) (Math.random() * 30) + 1;
for (int j = 0; j < i; j++) {
if (arr2[i] == arr2[j]) {
i--;
break;
}
}
}
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
}
}练习：回形数格式方阵的实现
从键盘输入一个整数（1~20） ，则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。
例如：
输入数字2，则程序输出：
1 2
4 3
输入数字3，则程序输出：
1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
官方参考代码：
法一：
class RectangleTest {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("输入一个数字");
int len = scanner.nextInt();
int[][] arr = new int[len][len]; //默认初始化的值都为0
int s = len * len;
/*
* k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
*/
int k = 1;
int i = 0, j = 0;
for (int m = 1; m <= s; m++) {
if (k == 1) {
if (j < len && arr[i][j] == 0) {
arr[i][j++] = m;
} else {
k = 2;
i++;
j--;
m--;
}
} else if (k == 2) {
if (i < len && arr[i][j] == 0) {
arr[i++][j] = m;
} else {
k = 3;
i--;
j--;
m--;
}
} else if (k == 3) {
if (j >= 0 && arr[i][j] == 0) {
arr[i][j--] = m;
} else {
k = 4;
i--;
j++;
m--;
}
} else if (k == 4) {
if (i >= 0 && arr[i][j] == 0) {
arr[i--][j] = m;
} else {
k = 1;
i++;
j++;
m--;
}
}
}
// 遍历
for (int m = 0; m < arr.length; m++) {
for (int n = 0; n < arr[m].length; n++) {
System.out.print(arr[m][n] + "\t");
}
System.out.println();
}
}
}法二：
class RectangleTest1 {
public static void main(String[] args) {
int n = 7;
int[][] arr = new int[n][n];
int count = 0; // 要显示的数据
int maxX = n - 1; // x轴的最大下标
int maxY = n - 1; // Y轴的最大下标
int minX = 0; // x轴的最小下标
int minY = 0; // Y轴的最小下标
while (minX <= maxX) {
for (int x = minX; x <= maxX; x++) {
arr[minY][x] = ++count;
}
minY++;
for (int y = minY; y <= maxY; y++) {
arr[y][maxX] = ++count;
}
maxX--;
for (int x = maxX; x >= minX; x--) {
arr[maxY][x] = ++count;
}
maxY--;
for (int y = maxY; y >= minY; y--) {
arr[y][minX] = ++count;
}
minX++;
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
String space = (arr[i][j] + "").length() == 1 ? "0" : "";
System.out.print(space + arr[i][j] + " ");
}
System.out.println();
}
}
}4. 数组中设计的常见算法
- 数组元素的赋值(杨辉三角、回形数等)
- 求数值型数组中元素的最大值、最小值、平均数、总和等
- 数组的复制、反转、查找(线性查找、二分法查找)
- 数组元素的排序算法
4.1 基本操作示例
public static void arrayTest(){
int[] arr1;
int[] arr2;
arr1 = new int[]{2,3,5,7,11,13,17,19};
// display
System.out.println("print arr1");
for (int i : arr1) {
System.out.print(i + "\t");
}
arr2 = new int[arr1.length];// copy
// arr2 = arr1; fuzhi
for (int i = 0; i < arr1.length; i++) {
// arr2[i]=arr1[i]; // copy
if(i%2==0)arr2[i]=i;
}
//print
System.out.println();
System.out.println("print arr1");
for (int i : arr1) {
System.out.print(i+"\t");
}
}array1 和 array2 的关系：
直接赋值，则array1 和 array2 地址值相同，都指向了堆空间的唯一的一个数组实体。
将array1的值复制给array2的话，地址值不同，不会指向同一数组实体。
4.2 数组的复制、反转、二分查找
注意：二分查找的前提是数组有序。
public static void arrayTest(){
int[] arr1;
int[] arr2;
arr1 = new int[]{2,3,5,7,11,13,17,19};
//copy
arr2 = new int[arr1.length];// copy
for (int i = 0; i < arr1.length; i++) {
arr2[i]=arr1[i]; // copy
}
//print
System.out.println();
System.out.println("print copied arr2");
for (int i : arr2) {
System.out.print(i+"\t");
}
//convert
//solution1
for (int i = 0; i < arr1.length; i++) {
arr2[arr1.length-i-1]=arr1[i];
}
arr1 = arr2;
//solution2：
// for(int i = 0;i < arr1.length / 2;i++){
// int temp = arr1[i];
// arr1[i] = arr1[arr1.length - i - 1];
// arr1[arr1.length - i - 1] = temp;
// }
//solution3：
// for(int i = 0,j = arr1.length - 1;i < j;i++,j--){
// int temp = arr1[i];
// arr1[i] = arr1[j];
// arr1[j] = temp;
// }
// print
System.out.println();
System.out.println("print converted arr2");
for (int i : arr1) {
System.out.print(i + "\t");
}
//find:er_fen_cha_zhao
int choose_number = 1;
int start = 0;
int end = arr1.length-1;
boolean is_find = false;
while(start<end){
int middle = (int)(start+end)/2;
if(arr1[middle]==choose_number){
System.out.println("find! the index is: "+middle);
is_find = true;
break;
}
else if(arr1[middle]>choose_number){
end = end-1;
}
else{
start = start+1;
}
}
if(!is_find){
System.out.println();
System.out.println("not find.");
}
}5. 数组元素的排序算法
- 排序：假设含有 n 个记录的序列为
,其相应的关键字序列为
。将这些记录重新排序为
,使得相应的关键字值满足条件
,这样的一种操作称为排序。
- 通常来说，排序的目的是快速查找。
- 衡量排序算法的优劣：
- 时间复杂度：分析关键字的比较次数和记录的移动次数
- 空间复杂度：分析排序算法中需要多少辅助内存
- 稳定性：若两个记录 A 和 B 的关键字值相等，但排序后 A、B 的先后次序保持不变，则称这种排序算法是稳定的。
- 排序算法分类：内部排序和外部排序。
- 内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
- 外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。
5.1 十大内部排序算法
说明：满足确定性的算法也称为：确定性算法。现在人们也关注更广泛的概念，例如考虑各种非确定性的算法，如并行算法、概率算法等。另外，人们也关注并不要求终止的计算描述，这种描述有时被称为过程（procedure）。
- 排序算法
- 选择排序
- 直接选择排序、堆排序
- 交换排序
- 冒泡排序、快速排序
- 插入排序
- 直接插入排序、折半插入排序、Shell 排序
- 归并排序
- 桶式排序
- 基数排序
- 排序算法性能比较
- 各种内部排序方法性能比较
- 从平均时间而言：快速排序最佳。但在最坏情况下时间性能不如堆排序和归并排序。
- 从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序算法，其算法比较复杂，认为是复杂排序。
- 从稳定性看：直接插入排序、冒泡排序和归并排序是稳定的；而直接选择排序、快速排序、Shell排序和堆排序是不稳定排序
- 从待排序的记录数n的大小看，n较小时，宜采用简单排序；而n较大时宜采用改进排序。
- 排序算法的选择
1.若n较小(如n≤50)，可采用直接插入或直接选择排序。当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
2. 若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；
3. 若n较大，则应采用时间复杂度为****的排序方法：快速排序、堆排序或归并排序。
本阶段主要掌握冒泡排序和快速排序。以后会专门写一篇博客讲解排序算法原理和实现，后续再更新。
5.2 冒泡排序 （Bubble Sort）
- 基本概念
冒泡排序通过重复地走访要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。 - 原理描述
通过对待排序序列从前向后，依次比较相邻元素的排序码，若发现逆序则交换，使排序码较大的元素逐渐从前部移向后部。 - 实现步骤（默认升序的情况）
- 比较相邻的元素，如果前一个比后一个大，就交换这两个数；
- 针对所有元素重复以上的步骤，最后一个除外，直到没有任何一对数字需要交换位置为止。
- 示例
package pers.chh3213.sort;
import java.util.Iterator;
import java.util.Scanner;
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {5,4,1,966,2,3,56,89,12,0,56562};
System.out.println("before sort:");
for (int i : arr) {
System.out.print(i+"\t");
}
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]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println();
System.out.println("after sort:");
for (int i : arr) {
System.out.print(i+"\t");
}
}
}因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序， 因此可以在排序过程中设置一个标志swap判断元素是否进行过交换，从而减少不必要的比较。改进代码如下：
public static void bubbleSort(int[] data) {
for (int i = 0; i < data.length-1; i++) {
Boolean swap = false;
for (int j = 0; j < data.length-i-1; j++) {
if(data[j]>data[j+1]) {
int temp = data[j];
data[j]= data[j+1];
data[j+1] = temp;
swap = true;
}
}
if(!swap)break; //不交换时停止排序
}
}- 冒泡排序的效率分析
5.3 快速排序（Quick Sort）
- 由图灵奖获得者Tony Hoare发明，被列为20世纪十大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为
。
- 快排采用了分治法的思想。
- 排序思想
- 从数列中挑出一个元素，称为"基准"（pivot），一般取第一个元素；
- 通过一次划分，将待排元素分为左右两个子序列，所有元素比基准值小的摆放在左序列，所有元素比基准值大的摆在右序列（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 然后分别对两个子序列继续进行划分，直至每一个序列只有一个元素为止；
- 最后得到的序列便是有序的序列。
- 一次划分的具体过程
- low指向待划分区域首元素（index=0）, high指向待划分区域尾元素（index=R.length-1）;
- base=R[low] (为了减少数据的移动,将作为标准的元素暂存到临时变量base中,最后再放入最终位置);
- high从后往前移动直到R[high]<base;
- R[low]=R[high], low++;
- low从前往后移动直到R[low]>=base;
- R[high]=R[low], high–;
- goto 3;
- 直到low==high时, R[low]=base (即将作为标准的元素放到其最终位置)。
概括地说,一次划分就是从表的两端交替地向中间进行扫描,将小的放到左边,大的放到右边,作为标准的元素放到中间。
之后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。
- 一次划分的具体过程示例
- low指向待划分区域首元素, high指向待划分区域尾元素;
- R[0]=R[low] (为了减少数据的移动,将作为标准的元素暂存到R[0]中,最后再放入最终位置);
- high从后往前移动直到R[high].key<R[0].key;
- R[low]=R[high], low++;
- low从前往后移动直到R[low].key>=R[0].key;
- R[high]=R[low], high–;
- goto 3;
8. 直到low==high时, R[low]=R[0] (即将作为标准的元素放到其最终位置)。
- 示例
package pers.chh3213.sort;
public class QuickSort {
public static void main(String[] args) {
System.out.println("quick sort test");
int[] arr = {9, -16, 30, 23, -30, -49, 25, 21, 30};
System.out.println("before sort:");
for (int i : arr) {
System.out.print(i+"\t");
}
quickSort(arr, 0, arr.length-1);
System.out.println();
System.out.println("after sort:");
for (int i : arr) {
System.out.print(i+"\t");
}
}
public static void quickSort(int[] arr,int start, int end) {
if(start<end) {
int index = partition(arr, start, end); //将表一分为2
quickSort(arr, start, index-1); // 对左子序列进行快速排序
quickSort(arr, index+1, end); //对右子序列进行快速排序
}
}
// 一次划分
public static int partition(int[] arr, int low,int high) {
int base = arr[low]; //暂存基准元素到base
while (low<high) {//从表的两端交替的向中间扫描
while(low<high && arr[high]>=base)high--;//右端扫描
if(low<high) {
arr[low]=arr[high];//把比基准小的元素放到基准前面
low++;
}
while(low<high && arr[low]< base)low++;//左端扫描
if(low<high) {
arr[high]=arr[low];//把比基准大的元素放到基准后面
high--;
}
}
arr[low] = base;//把基准元素放到最终位置
return low;//返回基准元素所在的位置
}
}6. Arrays 工具类的使用
java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。
- 示例
package pers.chh3213.sort;
import java.util.Arrays;
public class ArrayClassTest {
public static void main(String[] args) {
int[] arr1 = new int[] {2,5,10,456,4,23,15684,8749};
int[] arr2 = new int[] {2,5,10,456,4,203,15684,8749};
//判断两个数组是否相等
boolean is_equal = Arrays.equals(arr1, arr2);
System.out.println("is equal? "+ is_equal);
//输出数组信息
System.out.println(Arrays.toString(arr1));
//将指定值填充到数组之中--感觉很鸡肋
// Arrays.fill(arr1, 100);
// System.out.println(Arrays.toString(arr1));
//对数组进行排序
Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));
//对排序后的数组进行二分法检索指定的值
int index = Arrays.binarySearch(arr1, 456);
System.out.println(index);
}
}7. 数组使用中的常见异常
8. 数组的一些练习
用数组求出斐波那契数列的前20项值
package pers.chh3213.sort;
import java.util.*;
public class Fibonacci {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("How many Fibonacci do you want to obtain: ");
int number = scanner.nextInt();
int[] fibonacci = new int[number];
fibonacci[0]=0;
fibonacci[1]=1;
if(fibonacci.length>2) {
for (int i = 2; i < fibonacci.length; i++) {
fibonacci[i] = fibonacci[i-1]+fibonacci[i-2];
}
}
for (int i : fibonacci) {
System.out.print(i+"\t");
};
}
}求一个3*3矩阵对角线元素之和
package pers.chh3213.sort;
import java.util.Arrays;
public class ArrayClassTest {
public static void main(String[] args) {
int[][] arr = new int[3][3];
for (int i =0;i<arr.length;i++) {
for (int j=0;j<arr[i].length;j++) {
arr[i][j]= (int)(Math.random()*30);
}
}
for (int[] is : arr) {
for (int is2 : is) {
System.out.print(is2+"\t");
}
System.out.println();
}
int sum = 0;
for (int i =0;i<arr.length;i++) {
for (int j=0;j<arr[i].length;j++) {
if(i==j)sum+=arr[i][j];
}
}
System.out.println("sum is: "+ sum);
}
}有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
package pers.chh3213.sort;
import java.util.*;
public class ArrayInsert {
public static void main(String[] args) {
int[] arr = new int[] {1,2,4,5,8};
int[] arr2 = new int[arr.length+1];
System.out.println(Arrays.toString(arr));
Scanner scanner = new Scanner(System.in);
System.out.println("please input your number that you want to insert: ");
int number = scanner.nextInt();
if(number>=arr[arr.length-1]) {
arr2[arr2.length-1]=number;
for (int i = 0; i < arr.length; i++) {
arr2[i] =arr[i];
}
}
else {
Boolean insert_flag = true;
for (int i = 0,j=0; i < arr.length; i++,j++) {
arr2[j] =arr[i];
if(number<=arr[i] && insert_flag) {
insert_flag = false;
arr2[j]=number;
i--;
}
}
}
System.out.println(Arrays.toString(arr2));
}
}有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
package pers.chh3213.sort;
import java.util.*;
public class ArrayMove {
public static void main(String[] args) {
int[] arr = new int[]{2,4,5,6,8,29,2,10,2132};
System.out.println(Arrays.toString(arr));
int m = 5;
int[] arr2 = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
if(i>=arr.length-m) {
arr2[i-arr.length+m] = arr[i];
}
else{arr2[m+i] =arr[i];}
}
System.out.println(Arrays.toString(arr2));
}
}定义一个4行4列的二维数组，逐个从键盘输入值，然后将第1行和第4行的数据进行交换，将第2行和第3行的数据进行交换
package pers.chh3213.array;
public class MultiArraySwap {
public static void main(String[] args) {
int[][] arr = new int[4][4];
System.out.println("before swap");
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr[i][j]= (int)(Math.random()*30);
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
if(i==0)swap(arr, i, i+3, j);
if(i==1)swap(arr, i, i+1, j);
}
}
System.out.println();
System.out.println("after swap:");
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
public static void swap(int[][] arr, int i,int j,int index ) {
int temp = arr[i][index];
arr[i][index]= arr[j][index];
arr[j][index]= temp;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
