【尚硅谷_java基础】四、数组

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量640 收藏 6
点赞数 2
分类专栏： # java基础 文章标签： java 排序算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42301220/article/details/122079684
版权

文章目录

参考资料

  1. https://www.runoob.com/java/java-array.html
  2. https://www.cnblogs.com/huangminwen/p/5928315.html
  3. https://blog.csdn.net/qq_36743482/article/details/78527312
  4. https://www.bilibili.com/video/BV1Kb411W75N

1.数组的概述

  1. 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

  2. 数组的相关概念：
    数组名
    元素
    角标、下标、索引：从0开始
    数组的长度：元素的个数

  3. 数组的特点：
    在这里插入图片描述

2. 一维数组的使用

2.1 声明

在这里插入图片描述

2.2 初始化

在这里插入图片描述

2.3 数组元素的引用

在这里插入图片描述

2.4 数组元素的默认初始化值

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。
对于基本数据类型，默认初始化值各有不同；
对于引用数据类型，默认初始化值null。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.5 内存的简化结构

  1. 栈空间（stack），连续的存储空间，遵循后进先出的原则，用于存放局部变量。
  2. 堆空间（heap），不连续的空间，用于存放new出的对象，或者说是类的实例。
  3. 方法区（method），方法区在堆空间内，用于存放：
    类的代码信息；
    静态变量和方法；
    常量池（字符串敞亮等，具有共享机制）。
  4. Java中除了基本数据类型，其他的均是引用类型，包括类、数组等等。
  5. 变量初始化
    成员变量可不初始化，系统会自动初始化；
    局部变量必须由程序员显式初始化，系统不会自动初始化。

通俗地说：

  1. 栈：
    基本数据类型直接在栈中分配空间，局部变量（在方法代码段中定义的变量）也在栈中直接分配空间，当局部变量所在方法执行完成之后该空间便立刻被JVM回收，还有一种是引用数据类型，即我们通常所说的需要用关键字new创建出来的对象所对应的引用也是在栈空间中，此时，JVM在栈空间中给对象引用分配了一个地址空间（相当于一个门牌号，通过这个门牌号就可以找到你家），在堆空间中给该引用的对象分配一个空间，栈空间中的地址引用指向了堆空间中的对象区（通过门牌号找住址）；
  2. 堆：
    一般用来存放用关键字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 个记录的序列为 R 1 ， R 2 , … , R n {R_1，R_2,…,R_n} R1​，R2​,…,Rn​,其相应的关键字序列为 K 1 ， K 2 ， … , K n {K_1，K_2，…,K_n} K1​，K2​，…,Kn​。将这些记录重新排序为 R i 1 , R i 2 , … , R i n {Ri1,Ri2,…,Rin} Ri1,Ri2,…,Rin,使得相应的关键字值满足条件 K i 1 < = K i 2 < = … < = K i n Ki1<=Ki2<=…<=Kin Ki1<=Ki2<=…<=Kin,这样的一种操作称为排序。

  • 通常来说，排序的目的是快速查找。

  • 衡量排序算法的优劣：

    • 时间复杂度：分析关键字的比较次数和记录的移动次数
    • 空间复杂度：分析排序算法中需要多少辅助内存
    • 稳定性：若两个记录 A 和 B 的关键字值相等，但排序后 A、B 的先后次序保持不变，则称这种排序算法是稳定的。

  • 排序算法分类：内部排序和外部排序。

    • 内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
    • 外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

5.1 十大内部排序算法

在这里插入图片描述

说明：满足确定性的算法也称为：确定性算法。现在人们也关注更广泛的概念，例如考虑各种非确定性的算法，如并行算法、概率算法等。另外，人们也关注并不要求终止的计算描述，这种描述有时被称为过程（procedure）。

  • 排序算法
  • 选择排序
    • 直接选择排序、堆排序
  • 交换排序
    • 冒泡排序、快速排序
  • 插入排序
    • 直接插入排序、折半插入排序、Shell 排序
  • 归并排序
  • 桶式排序
  • 基数排序
  • 排序算法性能比较
    在这里插入图片描述
  • 各种内部排序方法性能比较
  1. 从平均时间而言：快速排序最佳。但在最坏情况下时间性能不如堆排序和归并排序。
  2. 从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序算法，其算法比较复杂，认为是复杂排序。
  3. 从稳定性看：直接插入排序、冒泡排序和归并排序是稳定的；而直接选择排序、快速排序、Shell排序和堆排序是不稳定排序
  4. 从待排序的记录数n的大小看，n较小时，宜采用简单排序；而n较大时宜采用改进排序。
  • 排序算法的选择

1.若n较小(如n≤50)，可采用直接插入或直接选择排序。当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
2. 若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；
3. 若n较大，则应采用时间复杂度为** O ( n l g n ) O(nlgn) O(nlgn)**的排序方法：快速排序、堆排序或归并排序。

本阶段主要掌握冒泡排序和快速排序。以后会专门写一篇博客讲解排序算法原理和实现，后续再更新。

5.2 冒泡排序 （Bubble Sort）

  • 基本概念
    冒泡排序通过重复地走访要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

  • 原理描述
    通过对待排序序列从前向后，依次比较相邻元素的排序码，若发现逆序则交换，使排序码较大的元素逐渐从前部移向后部。

  • 实现步骤（默认升序的情况）

    1. 比较相邻的元素，如果前一个比后一个大，就交换这两个数；
    2. 针对所有元素重复以上的步骤，最后一个除外，直到没有任何一对数字需要交换位置为止。

在这里插入图片描述

  • 示例
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世纪十大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为 O ( n l o g ( n ) ) O(nlog(n)) O(nlog(n))。

  • 快排采用了分治法的思想。

  • 排序思想

    1. 从数列中挑出一个元素，称为"基准"（pivot），一般取第一个元素；
    2. 通过一次划分，将待排元素分为左右两个子序列，所有元素比基准值小的摆放在左序列，所有元素比基准值大的摆在右序列（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
    3. 然后分别对两个子序列继续进行划分，直至每一个序列只有一个元素为止；
    4. 最后得到的序列便是有序的序列。
      在这里插入图片描述在这里插入图片描述

  • 一次划分的具体过程

    1. low指向待划分区域首元素（index=0）, high指向待划分区域尾元素（index=R.length-1）;
    2. base=R[low] (为了减少数据的移动,将作为标准的元素暂存到临时变量base中,最后再放入最终位置);
    3. high从后往前移动直到R[high]<base;
    4. R[low]=R[high], low++;
    5. low从前往后移动直到R[low]>=base;
    6. R[high]=R[low], high–;
    7. goto 3;
    8. 直到low==high时, R[low]=base (即将作为标准的元素放到其最终位置)。

    概括地说,一次划分就是从表的两端交替地向中间进行扫描,将小的放到左边,大的放到右边,作为标准的元素放到中间。
    之后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。

  • 一次划分的具体过程示例

    1. low指向待划分区域首元素, high指向待划分区域尾元素;
      在这里插入图片描述
    2. R[0]=R[low] (为了减少数据的移动,将作为标准的元素暂存到R[0]中,最后再放入最终位置);
      在这里插入图片描述
    3. high从后往前移动直到R[high].key<R[0].key;
      在这里插入图片描述
    4. R[low]=R[high], low++;

在这里插入图片描述

  1. low从前往后移动直到R[low].key>=R[0].key;
    在这里插入图片描述
  2. R[high]=R[low], high–;
    在这里插入图片描述
  3. 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;
	}
}
CHH3213
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础④数组
weixin_43874447的博客
08-10 143
今日内容 数组语法 数组异常 数组常用操作及排序算法 二维数组 第1章数组语法 声明方式：       类型[] 数组名;       类型 数组名[];       使用数组时必须分配长度     &nbsp...
java基础8_数组
weixin_43443344的博客
05-03 271
数组的概念 是一种容器，可以同时存放多个数值 数组的特点： 1.数组是一种引用数据类型 2.数组当中的多个数据，类型必须统一 3.数组的长度在程序运行期间不可改变 数组初始化 在内存中创建一个数组，并且向其中赋予一些默认值。 两种常见的初始化方式： 1.动态初始化（指定长度） 2.静态初始化（指定内容） 动态初始化数组的格式： 创建数组的时候，直接指定数组中元素个数 数据类型[] 数组名称 = new 数据类型[数组长度] 解析含义： 左侧数据类型： 也就是数组中保存的数据，全都是统一的类型（int、do
数组存储在栈中还是堆中
热门推荐
yuanbinquan的专栏
08-31 2万+
今天看代码，定义了一个结构体 typedef struct {     int a;     int b;     int char[6*1024]; } ss_t; //定义一个指针 ss_t *sTmp = NULL; sTmp = malloc(sizeof(ss_t));  我的第一反应是，怎么可以定义这么大数据，容易把栈搞死（理由：数组保存在栈空间）。 哎...忘了是
数组是分配在栈中的
qq_35779815的博客
07-03 8852
关于JAVA堆，下面说法错误的是（）？ 正确答案: C 你的答案: B (错误) 所有类的实例和数组都是在堆上分配内存的 堆内存由存活和死亡的对象，空闲碎片区组成 数组是分配在栈中的 对象所占的堆内存是由自动内存管理系统回收 JVM 关于堆和栈 Java 把内存划分成两种：一种是栈内存，另一种是堆内存。 栈式存储： 在函数中定义的一些基本类型的变量...
new创建对象，保存在堆内存还是栈内存
weixin_43768579的博客
05-03 995
new创建对象，保存在堆内存还是栈内存。栈内存是用来存放在函数中定义的一些。
java stack 数组_Java实现栈Stack_栈内部使用数组存储结构
weixin_31021649的博客
02-16 292
Java实现栈Stack_栈内部使用数组存储结构抽象数据类型栈的定义：栈(stack)，是限定在表尾进行插入或删除操作的线性表，因此对栈来说表尾有其特殊的含义，称为栈顶，相应的，表头端称为栈底。不含元素的空表称为空栈。栈-后进先出(last in first out)栈-顺序栈-栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素具体可参考java.util.Stack;内部...
尚硅谷_宋红康_20天Java核心_资料工具
03-17
1. **Java基础语法**：包括变量、数据类型、运算符、流程控制（如if语句、switch语句、循环结构for、while和do-while）、数组以及方法的定义与调用。这些基础知识是学习Java的起点，掌握它们能帮助初学者编写简单的...
2.尚硅谷_佟刚_java基础_java基本语法
08-22
• 2.1 关键字 • 2.2 标识符 • 2.3 变量 • 2.4 进制 • 2.5 运算符 • 2.6 流程控制 – 选择结构 – 循环结构 • 2.7 数组 – 一维数组 – 多维数组
尚硅谷_宋红康_Java9新特性1
08-04
Java 9是Java发展历程中的一个重要里程碑，它引入了大量的新特性，旨在提高开发效率、增强性能以及简化代码管理。以下是对这些关键特性的详细说明： 1. **模块化系统（Project Jigsaw）**：这是Java 9中最显著的...
尚硅谷_宋红康_第9章节练习_Java常用类.doc
07-05
【Java基础知识】 Java是一种广泛使用的面向对象的编程语言，具有平台无关性、安全性、健壮性和高效性等特点。在本教程中，宋红康老师深入浅出...在尚硅谷官网，你可以找到更多的Java、大前端和大数据相关的学习资料。
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。Java以其“一次编写，到处运行”的特性，成为跨平台应用开发的首选语言。Java的基础部分主要包括...
对象并不一定都是在堆上分配内存的。
weixin_44476888的博客
04-26 471
前段时间，给星球的球友们专门码了一篇文章《深入分析Java的编译原理》，其中深入的介绍了Java中的javac编译和JIT编译的区别及原理。并在文中提到：JIT编译除了具有缓存的功能外，还会对代码做各种优化，比如：逃逸分析、 锁消除、 锁膨胀、 方法内联、 空值检查消除、 类型检测消除、 公共子表达式消除等。 有球友阅读完这部分内容后，对JVM产生了浓厚的兴趣，自己回去专门学习了一下，在学习过程...
数组在栈上的分配
qq_39795050的博客
11-24 1972
数组在栈上的分配 gcc分配数组内存 创建了一个长度为N的字节数组，C编译器的在栈上的空间分配很有意思 处理器总是以16字节为单位分配栈空间 比如当数组长度为2字节时，处理器会分配16字节的空间，但是当数组长度为9字节时，处理器直接分配了32字节，当数组长度为25字节时，处理器会分配48字节。 可以发现一个规律，当数组的字节长度 > 16k -8时，处理器会分配（k+1）*16的空间 如果再声明一个数组，整数等，处理器继续按16字节分配内存，且都是先分配数组再分配普通变量 mov %fs
面试_数据结构基础
qq_41612830的博客
03-14 265
目录1 常见的数据结构1.1 数组(Array)基本概念特性1.2 栈(stack)1.3 队列(Queue)1.4 链表(Linked List)1.5 图1.6 树二叉树(Binary Tree)红黑树(Binary Tree)1.7 散列表（哈希表）2 那你说一下数组和链表的区别吧？数组链表 了解数据结构吗？说一下常见的数据结构？xysj面试 1 常见的数据结构 1.1 数组(Array) 基本概念 数组是一种线性表数据的结构，他用一组连续的内存空间，来存储一组相同数据类型的数据。每一个数组元素的位置
数组在栈和堆中的分配
m0_46672151的博客
03-02 1740
文章转载自：Java数组—栈内存与堆内存的区别（通过数组讲解） Java数组 针对于Java数组，Java语言把内存分为两种：-栈内存和堆内存。 栈内存： 在方法中定义的一些基本类型的变量和对象的引用变量都在方法的栈内存中分配,当在一段代码块中定义一个变量时,Java就在栈内存中为这个变量分配内存空间,当超出变量的作用域后,Java会自动释放掉为该变量所分配的内存空间。 堆内存： 堆内存用来存放 new 运算符创建的对象和数组,在堆中分配的内存,由Java虚拟机的自动垃级回收器来管理。在堆中创建了一个数组或
记录一下自己牛客网刷题的错题
qihuaiyu7的博客
08-20 1万+
1.广义表即我们通常所说的列表（lists)。它放松了对表元素的原子性限制，允许他们有自身结构。那么广义表E((a,(a,b),((a,b),c)))的长度和深度分别为： 正确答案：1和4 解析：广义表长度=属于最外层括号的逗号数加一。本题逗号为0 所以长度为1广义表深度=删除几层括号后可成为一个序列。 2.稀疏矩阵一般的压缩存储方法有两种,即() 正确答案：三元组和十字链表 解析：三元组顺序表又...
数组以及链表相关
weixin_42098680的博客
06-03 842
1、矩阵不仅表示多维数组，而且是表示图的重要工具。图的表示方法有邻接矩阵和邻接表。 2、对于不同的特殊矩阵应该采用不同的存储方式。 对称矩阵只需要存一半，三角矩阵也有自己的存储方式。 3、二维数组可以理解为一维的一维，一维数组是线性表，那么二维数组可以看成数据元素为线性表的线性表。 4、数组名代表的是数组的首地址，是一个地址常量，所以不能给数组名赋值。 char * strcpy(char * dest,const char * src) // c语言的方法，将src内容存放到dest中， 5、c语言宏
配置Java开发环境
最新发布
Broken_x的博客
07-10 1590
Java开发环境配置
尚硅谷__图解java设计模式.pdf
07-31
尚硅谷是一家提供职业教育培训的机构，他们出版了《图解Java设计模式》这本书。 这本书主要介绍了Java设计模式的内容。设计模式是一种在软件设计中常用的解决问题的方法，它提供了一套通用的解决方案，帮助我们在开发过程中更加高效地解决各种问题。 《图解Java设计模式》从实际开发中的场景出发，通过图解的方式，为读者详细介绍了23种常用的设计模式。每一种设计模式都有对应的UML图和实例代码，从而帮助读者理解和应用这些设计模式。 这本书首先介绍了设计模式的基本概念和原则，然后详细介绍了创建型模式、结构型模式和行为型模式。在介绍每一种设计模式时，书中都会提供一个实际的应用场景，并通过图示和代码示例进行详细的讲解，帮助读者更好地理解和掌握这些设计模式。 通过阅读《图解Java设计模式》，读者可以学习到如何利用不同的设计模式解决实际开发中的问题，提高代码的复用性、可维护性和扩展性。这本书适合已经具备一定Java开发经验的读者，对于希望提升自己的设计能力和编码水平的开发者来说，是一本值得推荐的书籍。 总之，《图解Java设计模式》是一本内容丰富、通俗易懂、实用性强的Java设计模式入门书籍，通过阅读并实践书中的内容，读者可以提升自己的软件设计和开发能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CHH3213

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值