目录
第一章、 了解Java
第二章、 基本语法—变量
第三章、 运算符
第四章、 程序控制结构
第五章、 数组、排序、查找
第六章、 面向对象编程（基础）
第五章、 数组、排序、查找
数组介绍
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即：数组就是一组数据。
5.1 数组
5.1.1 数组的创建和基本使用
数组是一种用于存储多个相同类型数据的数据结构。在 Java 中，数组是固定长度且具有连续内存空间的对象，可以通过索引访问和修改数组中的元素。以下是对数组的详细介绍：
- 创建数组： 在 Java 中，可以使用以下语法来创建一个数组：
dataType[] arrayName = new dataType[arrayLength];
其中，dataType 表示数组中存储的元素类型，arrayName 是数组的名称，arrayLength 是数组的长度（即可以存储的元素个数），[]也可以写在名称后面。例如，创建一个包含 5 个整数的数组：
int[] numbers = new int[5]; // 创建一个长度为 5 的整数数组
- 初始化数组： 数组可以通过逐个赋值或使用花括号初始化元素的方式进行初始化。例如：
int[] numbers = {1, 2, 3, 4, 5}; // 直接初始化数组元素
String[] names = new String[]{"Alice", "Bob", "Charlie"}; // 逐个赋值初始化
- 访问数组元素： 数组的元素可以通过索引访问，索引从 0 开始，并从左到右递增。例如，访问 numbers 数组的第一个元素：
int firstNumber = numbers[0]; // 获取第一个元素的值
- 修改数组元素： 可以通过索引修改数组中的元素的值。例如，将 numbers 数组的第二个元素修改为 10：
numbers[1] = 10; // 修改第二个元素的值为 10
- 获取数组长度： 可以使用 length 属性获取数组的长度。例如，获取 numbers 数组的长度：
int length = numbers.length; // 获取数组的长度
- 遍历数组： 可以使用循环结构（如 for 循环或 while 循环）遍历数组中的所有元素。例如，使用 for 循环遍历 numbers 数组，并打印每个元素的值：
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
数组在 Java 中是一个非常常用的数据结构，它可以方便地存储和操作一系列相同类型的数据。注意，数组的长度一旦确定，在其生命周期内无法更改，因此需要根据实际需求进行合理的设计和使用。
- 定义数组和使用
package chapter5;
public class Test1 {
//数组的定义
public static void main(String args[]){
//声明并分配空间,整型默认是0，浮点型默认是0.0，布尔值默认是false，字符默认是空字符，引用类型默认是null
int[] grade=new int[6]; //只能通过索引进行赋值
//声明并直接初始化
String[] course={"语文","数学","英语","物理","化学","生物",};
//声明并逐个初始化
String[] names=new String[]{"张三","李四","王五"};
//数组的访问，从0开始，n-1结束。n是数组长度，不支持负数索引
int a=grade[1];
//数组的修改，直接通过索引进行修改
course[4]="地理";
//获取数组的长度
System.out.println(grade.length);//输出6
System.out.println(a);//输出0
System.out.println(course);//输出数组的内存地址哈希码，[I 表示整型数组，@3b6eb2ec 是该数组对象的哈希码。
//普通的遍历数组
for(int i=0;i<course.length;i++){
System.out.println(course[i]);
}
//增强的for循环
for(String s:course){
System.out.println(s);
}
}
}
5.1.2 数组常用的方法和属性
在 Java 中，数组有一些常用的方法和属性，用于操作和获取数组的信息。以下是一些常用的数组方法和属性：
- length 属性：数组的长度，表示数组中元素的个数，使用方式为 array.length。例如：
int[] numbers = {1, 2, 3, 4, 5};
int length = numbers.length; // 获取数组的长度，结果为 5
- clone() 方法：用于创建并返回当前数组的一个副本，拷贝数组中的所有元素。例如：
int[] numbers = {1, 2, 3, 4, 5};
int[] copy = numbers.clone(); // 创建 numbers 数组的副本
- toString() 方法：将数组转换为字符串表示形式，结果为包含数组中每个元素的字符串，以逗号分隔，并用方括号括起来。例如：
int[] numbers = {1, 2, 3, 4, 5};
String str = Arrays.toString(numbers); // 将 numbers 数组转换为字符串
System.out.println(str); // 输出结果为 "[1, 2, 3, 4, 5]"
- sort() 方法：对数组中的元素进行升序排序。例如：
int[] numbers = {5, 3, 1, 4, 2};
Arrays.sort(numbers); // 对 numbers 数组进行排序
- binarySearch() 方法：对排序后的数组应用二分查找算法，查找指定元素的索引。前提是要先对数组进行排序。例如：
int[] numbers = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(numbers, 3); // 在 numbers 数组中查找元素 3 的索引
这些方法和属性都属于 java.util.Arrays 类，它提供了很多常见的操作数组的方法。需要注意的是，在使用这些方法时，要确保数组的类型正确，并且在调用某些方法之前可能需要先对数组进行排序。
- 熟悉使用数组的常用方法
package chapter5;
import java.util.Arrays;
public class Test2 {
public static void main(String args[]){
//数组属性和方法的使用
int[] numbers={1,6,2,3,5,4};
//求数组的长度
int len=numbers.length;
//拷贝数组
int[] copy=numbers.clone();
//将数组转为字符串
String str= Arrays.toString(numbers);
//对数组进行排序,默认是升序
Arrays.sort(numbers);
//对排序后的数组进行二分查找，查找指定元素的索引
int index = Arrays.binarySearch(numbers,4);//查找元素3的索引，如果没有则放回负数
//复制指定区域的数组
int[] num=Arrays.copyOfRange(numbers,1,4);//遵循左闭右开
//判断两个数组是否相等
boolean equal= Arrays.equals(numbers,copy);//相等就返回true，则返回false
}
}
5.1.3 数组赋值机制
在Java中，有以下几种赋值机制：
- 基本数据类型的赋值：对于基本数据类型（如int、double等），赋值操作会创建一个新的值的副本。这意味着当将一个基本数据类型的变量赋值给另一个变量时，值会被复制到新的变量中，而且两个变量之间互不影响。
int a = 5;
int b = a;
b = 10;
System.out.println(a); // 输出 5
System.out.println(b); // 输出 10
- 引用类型的赋值：对于引用类型（如数组、对象等），赋值操作只是将引用复制一份，仍然指向同一个对象。这意味着当将一个引用类型的变量赋值给另一个变量时，两个变量都指向同一个对象，它们之间共享相同的数据。
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;
arr2[1] = 5;
System.out.println(Arrays.toString(arr1)); // 输出 [1, 5, 3]
System.out.println(Arrays.toString(arr2)); // 输出 [1, 5, 3]
在这个例子中，对arr2进行的修改也会影响到arr1，因为它们引用同一个数组对象。
- 对象的克隆：有时候我们需要创建一个对象的副本，以便在修改副本时不影响原始对象。可以通过使用clone()方法来实现对象的克隆。
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1.clone();
arr2[1] = 5;
System.out.println(Arrays.toString(arr1)); // 输出 [1, 2, 3]
System.out.println(Arrays.toString(arr2)); // 输出 [1, 5, 3]
在这个例子中，通过arr1.clone()创建了一个arr1的副本arr2，对arr2进行的修改不会影响到arr1。
这些赋值机制在处理数据时非常重要，请根据具体情况选择适当的赋值方式。
-
请注意，数组的克隆只是浅拷贝（shallow copy），也就是说它只会复制数组中的引用，而不是实际的对象。如果数组中包含了其他对象类型的元素，那么这些对象不会被克隆，在新数组中仍然指向原始的对象。如果需要深度复制数组以及内部对象，需要编写自己的代码来实现。
-
如果需要进行深度复制，可以使用for循环逐个地遍历原始数组，并创建一个新的对象来存储每个元素的副本。这样可以确保在新数组中的对象是独立于原始对象的。
下面是一个示例代码，用于演示如何对包含字符串对象的数组进行深度复制：
public static String[] deepCopy(String[] originalArray) {
String[] newArray = new String[originalArray.length];
for (int i = 0; i < originalArray.length; i++) {
newArray[i] = new String(originalArray[i]);
}
return newArray;
}
在这个示例代码中，我们首先创建了一个与原始数组大小相同的新数组newArray。然后，通过for循环遍历原始数组的所有元素，并使用new关键字创建一个新的字符串对象来存储每个元素的副本。最后，将副本元素放入新数组newArray中并返回它。
请注意，在实际应用中，可能需要根据实际情况编写不同的代码来深度复制不同类型的对象。
5.1.4 数组的反转
在 Java 中，数组是没有直接提供反转的方法的，因此没有名为 reverse 的数组方法可用。你可以通过自己编写代码来完成数组的反转操作。
要反转一个数组，可以使用双指针的方法进行操作。具体步骤如下：
- 使用两个指针，一个指向数组的起始位置，另一个指向数组的末尾位置。
- 交换两个指针所指向的元素。
- 将指针向中间移动，重复步骤2，直到两个指针相遇（或者过界）为止。
以下是一个示例代码，演示了如何反转一个整型数组：
public static void reverseArray(int[] array) {
int left = 0;
int right = array.length - 1;
while (left < right) {
// 交换左右指针所指向的元素
int temp = array[left];
array[left] = array[right];
array[right] = temp;
// 移动指针
left++;
right--;
}
}
在这个示例代码中，我们定义了reverseArray方法，接受一个整型数组作为参数。使用left和right两个指针分别指向数组的起始位置和末尾位置。在循环中，不断交换指针所指向的元素，并将指针向中间移动。当两个指针相遇时，表示数组已经完成反转。
可以通过调用reverseArray方法来反转一个整型数组，例如：
int[] arr = {1, 2, 3, 4, 5};
reverseArray(arr);
System.out.println(Arrays.toString(arr));
//输出结果为：[5, 4, 3, 2, 1]，即数组已经成功反转。
实操：将一个排序好的数组进行翻转
package chapter5;
import java.util.Arrays;
public class Test3 {
public static void main(String args[]){
//数组只有升序的，那么如何降序呢，也就是进行反转操作，也没有直接的方法。用代码实现
int[] numbers={2,14,5,4,7,1,9,10};
Arrays.sort(numbers);
int left=0;
int right=numbers.length-1;
while(left<right){
int temp=numbers[left];
numbers[left]=numbers[right];
numbers[right]=temp;
left++;
right--;
}
for(int i=0;i<numbers.length;i++){
System.out.println(numbers[i]);
}
System.out.println(Arrays.toString(numbers));
}
}
5.1.5 数组扩容
- 要求:实现动态的给数组添加元素效果，实现对数组扩容。
- 原始数组使用静态分配int[] arr = {1,2,3}
- 增加的元素4,直接放在数组的最后arr = {1,2,3,4}
- 用户可以通过如下方法来决定是否继续添加,添加成功，是否继续?y/n
- 思路分析
- 定义初始数组int[] arr = {1,2,3}//下标0-2
- 定义一个新的数组int[ ] arrNew = new int[ arr.length+1];
- 遍历历arr 数组,依次将arr的元素拷贝到 arrNew数组
- 将4赋给arrNew[ arrNew.length - 1] =4;把4赋给arrNew最后一个元素
- 让 arr 指向arrNew ; arr = arrNew;那么原来arr数组就被销毁
- 两种不同的指向
1.第一种指向
//对于这段代码，arr1和arr2指向同一个数组对象，修改arr1或arr2中的元素将会影响另一个引用所指向的数组对象。
int[] arr1 = {1,2,3};
int[] arr2 = arr1;
2.第二种指向
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3, 4};
arr2 = arr1; // 将arr1赋值给arr2
/*这样，arr2就会指向arr1所指向的数组对象。arr2和arr1都指向同一个数组，所以修改其中一个引用中的元素会影响另一个引用所指向的数组。
当将arr1赋值给arr2时，原先的arr2所引用的数组对象{1, 2, 3, 4}就没有任何引用指向它了。在Java中，当一个对象没有任何引用指向时，
它就成为了垃圾，会被Java的垃圾回收机制销毁释放内存。
在这种情况下，原先的arr2所指向的数组对象{1, 2, 3, 4}会被当做垃圾销毁。通过将arr1赋值给arr2，arr2指向了一个新的数组对象{1, 2, 3}，
而原先的数组对象{1, 2, 3, 4}将会被销毁。
*/
- 图例分析：
5.1.6 数组使用注意事项和细节
- 数组是多个相同类型数据的组合，实现对这些数据的统一管理
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
- 数组创建后，如果没有赋值，有默认值int 0，short 0，byte 0，long 0，float 0.0，double0.0，char \u0000，boolean false，String null。
- 使用数组的步骤：1、声明数组并开辟空间，2、给数组各个元素赋值，3、使用数组。
- 数组的下标是从0开始的
- 数组的小标必须在指定范围内使用，否则报：下标越界异常，比如：int[] arr = new int[5];则有效下标为0-4.
- 数组属于引用类型，数组型数据是对象（object）
- 引用类型的对象（如数组、对象等）不能直接用 System.out.print() 和 System.out.println() 输出。如果使用 System.out.print() 和 System.out.println()，实际上输出的是引用类型对象的地址或哈希码，而不是对象所包含的具体内容。
5.2 排序
- 排序的介绍
排序是将一群数据，依指定的顺序进行排列的过程。 - 排序的分类:
- 内部排序:
指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法); - 外部排序法:
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)。
- 冒泡排序
冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历待排序序列，每次比较相邻的两个元素，如果它们的顺序不满足要求，就交换它们的位置。通过多次遍历，依次将最大（或最小）的元素“浮”到最右端（或最左端），直到整个序列有序。
下面是使用Java语言实现冒泡排序的示例代码：
package chapter5;
import java.util.Arrays;
public class Test4 {
public static void main(String args[]){
//冒泡排序的使用
int[] arr={1,43,45,32,6,3,54,34,2,10};
int len=arr.length;
for(int i=0;i<len;i++){
for(int j=0;j<len-i-1;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.print(Arrays.toString(arr));
}
}
冒泡排序时间复杂度为O(n^2)，空间复杂度为O(1)，是一种稳定的排序算法。这个算法思想简单易懂，但对于大规模数据的排序效率较低。
5.3 查找
Java中常用的查找算法包括线性查找和二分查找。
- 线性查找：在一个无序的列表中查找某个目标元素，比较容易实现。该算法从列表的一端开始逐个比较每个元素，直到找到匹配项或者搜索整个列表。时间复杂度为O(n)，其中n是列表的长度。
以下是Java代码实现线性查找的示例：
package chapter5;
import java.util.Scanner;
public class Test5 {
public static void main(String args[]){
//查找算法，线性查找,输入要查找的值
int[] numbers={1,4,5,9,2,3,10};
Scanner scanner=new Scanner(System.in);
int c=scanner.nextInt();
boolean b=false;
for(int i=0;i<numbers.length;i++){
if(numbers[i]==c){
System.out.print("这个值存在！");
b=true;
break;
}
}
if(!b){
System.out.print("这个值不存在！");
}
}
}
- 二分查找：二分查找需要对一个有序的列表进行查找。该算法先取列表的中间元素并与目标元素进行比较，然后根据比较结果确定要继续在左侧还是右侧查找。由于每次查找都可以排除一半的元素，因此算法的时间复杂度为O(logn)。
以下是Java代码实现二分查找的示例：
package chapter5;
import java.util.Scanner;
public class Test6 {
public static void main(String args[]){
//二分查找算法，要求有序
//输入一组数组和要查找的数字，判断代码是否正确
Scanner scanner=new Scanner(System.in);
String str=scanner.nextLine();//输入以空格为分隔符
int c=scanner.nextInt();//输入要查找的值
String[] strnum=str.split(" ");
int[] num=new int[strnum.length];
for(int i=0;i<num.length;i++){
num[i]=Integer.parseInt(strnum[i]);
}
int left=0;
int right=num.length-1;
boolean found=false;
while(left<=right){
int middle=(left+right)/2;
if(num[middle]==c){
System.out.print("查找值为："+num[middle]);
found=true;
break;
}else if(num[middle]<c){
left=middle+1;
}else{
right=middle-1;
}
}
if(!found){System.out.print("查无此值！"+c);}
}
}
以上是Java中常用的两种查找算法，根据数据的情况选择合适的算法可以提高查找效率。
5.4 二维数组的使用
- 直接初始化
这种方式可以在定义时直接初始化，常用于二维数组元素已知的情况。
int[][] array = {{1,2,3}, {4,5,6}, {7,8,9}};
- 动态初始化
先声明一个二维数组，然后再分配内存空间，可以通过循环赋值或通过索引一个一个赋值。
语法:类型[][] 数组名 = new 类型[大小][大小] 比如: int a[[=new int[2][3]
(1). 循环赋值
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
array[i][j] = i + j;
}
}
(2). 一个一个赋值
int[][] array = new int[3][3];
array[0][0] = 1;
array[0][1] = 2;
array[0][2] = 3;
array[1][0] = 4;
array[1][1] = 5;
array[1][2] = 6;
array[2][0] = 7;
array[2][1] = 8;
array[2][2] = 9;
- 二维数组在内存的存在形式
- 使用方式二：动态初始化
(1). 先声明：类型 数组名[][]；
(2). 再定义(开辟空间) 数组名 =new类型[大小][大小]
(3). 赋值(有默认值，比如int 类型的就是0)
(4). 使用演示
int[][] num;
num = new int[2][3];
- 使用方式三：动态初始化-列数不确定
int[][] array = new int[3][];
array[0] = new int[]{1, 2};
array[1] = new int[]{3, 4, 5};
array[2] = new int[]{6};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
- 二维数组使用细节和注意事项
(1). 一维数组的声明方式有：
Int[] x 或者 int x[]
(2). 二维数组的声明方式有：
Int[][] y 或者 int[] y[] 或者 int y[][]
(3). 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同，
5.5 本章练习
- 数组求和，计算数组中所有成绩的总和。
package chapter5;
import java.util.Scanner;
public class Test11 {
public static void main(String args[]){
Scanner scanner=new Scanner(System.in);
String str = scanner.nextLine();//输入要计算的成绩，以空格分隔
String[] strings=str.split(" ");
float[] grade=new float[strings.length];
for(int i=0;i<strings.length;i++){
grade[i]=Float.parseFloat(strings[i]);
}
float sum=0;
for(int i=0;i<grade.length;i++){
sum+=grade[i];
}
System.out.println("所有的成绩总分是："+sum);
}
}
- 对数组中重复的数组进行删除，只保留一个，并且保存原有的顺序。
package chapter5;
import java.util.Arrays;
import java.util.Scanner;
public class Test12 {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
String line = scanner.nextLine(); // 输入数组，以逗号分隔
String[] arr = line.split(",");
if (arr.length == 1 || arr.length == 0) {
System.out.println(arr.length == 0 ? "" : arr[0]);
} else {
// 创建一个布尔数组来跟踪哪些元素已经被添加到去重数组中
boolean[] added = new boolean[arr.length];
Arrays.fill(added, false); // 初始化为false
String[] arr2 = new String[arr.length];
int count = 0; // arr2的实际索引
for (int i = 0; i < arr.length; i++) {
if (!added[i]) { // 如果当前元素未被添加
arr2[count++] = arr[i]; // 添加到arr2
// 标记所有相同的元素为已添加
for (int j = i + 1; j < arr.length; j++) {
if (arr[i].equals(arr[j])) {
added[j] = true;
}
}
}
}
// 截取arr2以去除末尾的空元素
arr2 = Arrays.copyOf(arr2, count);
System.out.println(Arrays.toString(arr2));
}
scanner.close();
}
}
- 数组的删除，有一个数组{1，2，3，4，3}，可以将该数组进行缩减，提示用户是否继续缩减，每次缩减最后那个元素。当只剩下最后一个元素，提示，不能再缩减。
package jkjk;
import java.util.Scanner;
public class Kjjj {
public static void main(String[] args) {
Scanner myscanner = new Scanner(System.in);
int arr[] = {1, 2, 3, 4, 3};
System.out.println("请输入yes/no：");
while (myscanner.hasNext()) {
String input = myscanner.next();
if (arr.length == 1) {
System.out.println("对不起，只剩下一个元素了，不可以删减了！");
break;
}
if (input.equals("no")) {
break;
} else if (input.equals("yes")) {
int[] temp = new int[arr.length - 1];
System.arraycopy(arr, 0, temp, 0, arr.length - 1);
arr = temp;
} else {
System.out.println("输入错误，请重新输入！");
}
}
myscanner.close();
}
}
- 创建一个5×5的二维数组，并使用嵌套循环初始化它，使得对角线上的元素为1，其余元素为0，然后打印这个数组。
package chapter5;
public class Test7 {
public static void main(String args[]){
int[][] num=new int[5][5];
for(int i=0;i<num.length;i++){
for(int j=0;j<num[i].length;j++){
if(i==j){
num[i][j]=1;
}else{
num[i][j]=0;
}
}
}
for(int[] row:num){
for(int value:row){
System.out.print(value+" ");
}
System.out.println();
}
}
}
- 给定二维数组中查找特定元素，并输出其位置。
package chapter5;
import java.util.Scanner;
public class Test8 {
public static void main(String args[]){
int[][] matrix={{1,2,3,4},
{5,6,7,8},
{9,10,11,12},
{13,14,15,16},
{17,18,19,20}};
Scanner scanner =new Scanner(System.in);
int targit=scanner.nextInt();
boolean found=false;
for(int i=0;i<matrix.length;i++){
for(int j=0;j<matrix[i].length;j++){
if(matrix[i][j]==targit){
System.out.println(targit+"这个值的位置："+"["+i+","+j+"]");
found=true;
break;
}
}
}
if(!found){
System.out.println(targit+"这个值不存在！");
}
}
}
- 找出二维数组中的最小值
package chapter5;
public class Test9 {
public static void main(String args[]){
int[][] matrix={{-1,8,10},{-9,8,4},{4,8,14},{-19,-18,12}};
int max=0;
for(int i=0;i<matrix.length;i++){
for(int j=0;j<matrix[i].length;j++){
if(matrix[i][j]>max){
max=matrix[i][j];
}
}
}
System.out.println("这个数组的最大值："+max);
}
}
- 将二维数组进行转置操作，即行变为列，列变为行。
package chapter5;
public class Test10 {
public static void main(String args[]){
int [][] origianl={{1,2,3},
{4,5,6},
{7,8,9}};
int [][] transfer=new int[origianl.length][origianl[0].length];
for(int i=0;i<origianl.length;i++){
for(int j=0;j<origianl[i].length;j++){
transfer[i][j]=origianl[j][i];
}
}
for(int[] row:transfer){
for(int value:row){
System.out.print(value+" ");
}
System.out.println();
}
}
}
- 杨辉三角的实现。
规律
（1）. 第一行有1个元素,第n行有n个元素
（2）. 每一行的第一个元素和最后一个元素都是1
（3）. 从第三行开始，对于非第一个元素和最后一个元素的元素的值. arr[i][j]arr[ i][j]=arr[i-1][j] + arr[i-1][j-1];//必须找到这个规律
package chapter5;
public class Test13 {
public static void main(String args[]) {
//杨辉三角的实现
/* 1
* 1 1
* 1 2 1
* 1 3 3 1
* 1 4 6 4 1
* 1 5 10 10 5 1
* ………………………………
* */
//找规律：第一行有一个元素，第n行元素有n个元素
//每一行第一个和最后一个元素都是1
//从第三行开始，除了第一个元素和最后一个元素外，其他元素的规律是：得出递推式：arr[i][j]=arr[i-1][j]+arr[i-1][j-1]
//进行初始化，和定义数组，假设只求前10行的杨辉三角
int[][] arr = new int[10][];//初始化行数
for(int i=0;i<10;i++){//初始化列数
arr[i]=new int[i+1];
}
for (int i = 0; i < 10; i++) {//赋值1
arr[i][0] = 1;
arr[i][i] = 1;
}
for(int i=2;i<10;i++){//根据递推式赋值
for(int j=1;j<i;j++){
if(i!=j && j!=0)
arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
}
}
for(int[] row:arr){//打印输出
for(int value:row){
System.out.print(value+" ");
}
System.out.println();
}
}
}
- 已知存在一个数组是降序的状态，现要求插入一个随机值，需保持原有的降序状态。
package chapter5;
import java.util.Arrays;
import java.util.Random;
public class Test14 {
public static void main(String args[]){
Random random=new Random();
int r=random.nextInt(100);
int[] numbers={90,89,86,65,43,32,21,12,9};
int[] extend=new int[numbers.length+1];
for(int i=0;i<extend.length-1;i++){
extend[i]=numbers[i];
}
extend[extend.length-1]=r;
Arrays.sort(extend);
int left=0;
int right=extend.length-1;
while (left<right){
int temp=extend[right];
extend[right]=extend[left];
extend[left]=temp;
right--;
left++;
}
System.out.println(Arrays.toString(extend));
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
