这篇博客是基于上一篇博客的补充，完善一点关于Java数组的知识。如有错误欢迎指正。
 
 
 
 
一、数组
 
1.内存分配
 
1.1概述
 
内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。必须放进内存中才能运行，运行完毕后会清空内存。 Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。而在Java中每运行一个java程序会产生一个java进程，每个java进程可能包含一个或者多个线程，每一个Java进程对应唯一一个JVM实例，每一个JVM实例唯一对应一个堆，每一个线程有一个自己私有的栈。进程所创建的所有类的实例（也就是对象）或数组（指的是数组的本身，不是引用）都放在堆中,并由该进程所有的线程共享。Java中分配堆内存是自动初始化的，即为一个对象分配内存的时候，会初始化这个对象中变量。虽然Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在栈中分配,也就是说在建立一个对象时在堆和栈中都分配内存，在堆中分配的内存实际存放这个被创建的对象的本身，而在栈中分配的内存只是存放指向这个堆对象的引用而已。局部变量 new 出来时，在栈空间和堆空间中分配空间，当局部变量生命周期结束后，栈空间立刻被回收，堆空间区域等待GC回收。
 
而在Java中JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method，也叫静态区)。
 
1.2堆区
 
1.存储的全部是对象，每个对象都包含一个与之对应的class的信息(class的目的是得到操作指令) ；
 2.jvm只有一个堆区(heap)，且被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身和数组本身；
 
1.3栈区
 
1.每个线程包含一个栈区，栈中只保存基础数据类型本身和自定义对象的引用；
 2.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问；
 3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)；
 
1.4方法区
 
1.被所有的线程共享，方法区包含所有的class（class是指类的原始代码，要创建一个类的对象，首先要把该类的代码加载到方法区中，并且初始化）和static变量。 
 2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。
 
 
而我们需要重点记住的就是堆区和栈区。
 
2.遍历
 
2.1概念
 
 就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。我们对于数组的各种操作都是建立在将数组的元素取出来上的。只有搞清楚了怎么将元素从数组中取出来我们才能更好的操作。
 
2.2循环遍历
 
一般遍历数组采取的都是使用for循环来遍历数组我也只讲这一种，另外的可以自己思考一下。
 
首先我们需要定义一个存有元素的数组出来
 
//定义数组
int a[]={1,2,3,4,5,6};
 
然后我们要定义一个fro循环来进行遍历，这个时候就有一个问题了我们的循环需要循环几次呐？这个时候如果我们直接定义的数组能够知道有几个元素存在里面我们就是循环几次，而我们不知道的时候就可以用一个在jdk中给我们定义好的方法.length，在点之前就是你定义的数组的名字。
 
//知道数组内元素的个数的定义
for (int i = 0; i < 6; i++) {
            System.out.print(a[i] + "\t");
        }
//不知道元素个数的时候
for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "   ");
        }
 
注意直接使用的length是存储个数的多少，而索引是从0开始的所以我们的i不能等于元素的个数。
 
结果：
 
 
3.二维数组
 
在我们学习了一维数组之后在应用多了之后在有的时候用一维数组存东西就没有那么的方便了，而这个时候我们就需要用到一维数的升级版二维数组。
 
3.1定义
 
二维数组的定义和一维数组差不多就是多了一个框。也有两种定义方法。
 
//第一种定义方法
int a[][]=new int[大小][大小];
//第二种定义方法
int a[][]={{....},{....}....}
 
而我们可以这样来看二维数组就是二维数组的每一个元素都是一维数组，这样我们能更好的理解。
 
3.2二维数组的遍历
 
二维数组的遍历和一维数组的遍历差不多都是用循环实现只是要比一维数组多一层循环。
 
for(int i=0;i<a.length;i++){
            for(int j=0;j<a[i].length;j++){
                System.out.println(a[i][j]);
            }
        }
 
4.排序
 
当我们学习了数组之后我们有的时候又想讲数组的元素要么从小排到大要么从大排到小，这个时候我们就需要一个东西叫排序。一般的排序分三种，冒泡，选择，插入。
 
4.1冒泡排序
 
一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序，如果有n个数据进行排序，总共需要比较n-1次，每一次比较完毕，下一次的比较就会少一个数据参与。
 
图解：
 
 
 示例代码：
 
//冒泡排序
for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                     temp = arr[j];
                    arr[j] = arr[j+ 1];
                    arr[j+1] = temp;
                }
            }
        }
 
4.2选择排序
 
第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
 
图解：
 
 
示例代码：
 
 
 
//选择排序
 for (int i = 1; i < arr.length; i++) {
             int k = 0, j;
            for (j = 0; j <= arr.length - i; j ++) {
                if (arr[k] < arr[j])
                     k = j;
            }
            if (k != j) {
                 int temp = arr[k];
                arr[k] = arr[j-1];
                arr[j-1] = temp;
            }
        }
 
4.3插入排序
 
插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法   。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。
 
图解：
 
 
示例代码：
 
 
 
//插入排序
for (int i = 1; i < arr.length; i++) {
            int temp = arr[i], j;
             for (j = i - 1; j >= 0; j--) {
                if (arr[j] > temp) {
                      arr[j+1] = arr[j];  
                } else {
                    break;
                }
            }
            arr[j+1] = temp;
        }
 

Java头歌闯关第一步
 
标题第1关：数组的复制
 
创建一个数组arr2，数组长度和数组arr1相同；
使用循环将数组1中的每一个数据赋值给数组2中对应的那一项。（即arr2[0] = arr1[0]）；
循环输出复制之后arr2中的所有数据。
 
package step1;
import java.util.Scanner;
public class HelloWorld {
	public static void main(String[] args) {
		//动态构建arr1
		int[] arr1 = new int[3];
		Scanner sc = new Scanner(System.in);
		for(int i = 0 ; i< arr1.length ; i++){
			arr1[i] = sc.nextInt();
		}
		/********** Begin **********/
		//创建数组arr2
		int arr2[]=new int[3];
		//使用for循环将arr1的数据复制给arr2
		 for(int i=0;i<arr1.length;i++){
            arr2[i]=arr1[i];
        }
		//输出arr2
	        for(int i=0;i<arr2.length;i++){
            System.out.println(arr2[i]);
        }	
		/********** End **********/
	}
}
//简单玩玩
 
第2关：数组中元素的查找
 
在Java中判断两个字符串是否相等，需要使用equals方法；
 语法：字符串1.equals(字符串2) 如果字符串1等于字符串2返回true，否则返回false；
 
package step2;
import java.util.Scanner;
public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//str为要查找的字符串
		String str = sc.next();
		/********** Begin **********/
		//创建数组   arr  给数组赋值 {"张三","张三丰","张无忌","王二麻子","张富贵"}
		String arr[]=new String[]{"张三","张三丰","张无忌","王二麻子","张富贵"};
        for(int i=0;i<5;i++){
            if(str.equals(arr[i])){
                System.out.println(str+"在数组的第"+(i+1)+"个位置");
            }
        }
		/********** End **********/
	}
}

 
第3关：交换算法
 
三种方法进行交换：引入第三者/异或/相加；
 
int temp = a; //生成第三方临时变量temp，将a的值赋给它
 a = b;
 b = temp;
a = a ^ b;
 b = a ^ b;
 a = a ^ b;
a = a + b;
 b = a - b;
 a = a - b;
 java中直接进行swap交换会出现错误
 这里使用数组交换
 
import java.util.Scanner;
//数组进行交换
public class jiaohuan {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        int arr[]= {10,20};
        swap(arr);
        System.out.println(arr[0]+" "+arr[1]);
	}
	public static void swap(int arr1[]) {
		int t=arr1[0];
		arr1[0]=arr1[1];
		arr1[1]=t;
	}
}

 
第4关：选择排序
 
实现数组从大到小的排序（降序排序）
 
package shangji;

import java.util.Arrays;
import java.util.Scanner;
public class xuanze {
       public static void main(String args[]) {
		Scanner scanner=new Scanner(System.in);
		int arr[]=new int[scanner.nextInt()];//动态数组创建
		for(int i=0;i<arr.length;i++) {
			arr[i]=scanner.nextInt();
		}
        for (int i = 0; i < arr.length - 1; i++) {
             int min = i;
            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }
            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }
        }
		System.out.println(Arrays.toString(arr));
	}
}
 
第5关：冒泡排序
 
使用冒泡排序实现数组的升序排序（从小到大）
 
import java.util.Arrays;
import java.util.Scanner;

public class maopao {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		//动态创建数组
		int[] arr = new int[sc.nextInt()];
		for(int i = 0 ; i< arr.length ; i++){
			arr[i] = sc.nextInt();
		}
		/********** Begin **********/
		  for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
	}

}

第1关：数组的复制
 任务描述
 本关任务：完成将一个数组的值复制给另一个数组。
 相关知识
 本关需要你完成数组的复制操作，可以分三个步骤来实现。
 创建一个数组arr2，数组长度和数组arr1相同；
 使用循环将数组1中的每一个数据赋值给数组2中对应的那一项。（即arr2[0] = arr1[0]）；
 循环输出复制之后arr2中的所有数据。
 编程要求
 在右侧编辑器Begin-End中填充代码，将arr1数组中的数据全部复制给arr2数组，最后输出arr2中所有的数据。
 测试说明
 我会对你的程序进行测试，如下：
 测试输入：1，3，12
 预期输出：
 1
 3
 12
 测试输入：2，13，11
 预期输出：
 2
 13
 11
 开始你的任务吧，祝你成功！
 参考代码：
 
package step1;
import java.util.Scanner;
public class HelloWorld {
	public static void main(String[] args) {
		//动态构建arr1
		int[] arr1 = new int[3];
		Scanner sc = new Scanner(System.in);
		for(int i = 0 ; i< arr1.length ; i++){
			arr1[i] = sc.nextInt();
		}
		/********** Begin **********/
		//创建数组arr2
		int [] arr2= new int [3];
		//使用for循环将arr1的数据复制给arr2
		for(int i=0;i<arr2.length;i++){
			arr2[i]=arr1[i];
			System.out.println(arr2[i]);
		}
		//输出arr2
		/********** End **********/
	}
}
 
第2关：数组中元素的查找
 任务描述
 本关任务：完成查找字符串数组中指定字符串位置的小程序。
 相关知识
 为了完成本关任务，你需要知道：如何判断两个字符串是否相等。
 如何判断字符串相等
 我们之前判断两个数是否相等使用的是==符号，我们判断字符串是否相等能否用==符号呢？我们来看一段代码。
 
 输出结果：
 
 为什么呢？
 是因为==比较的是两个对象的内存地址，我们知道变量被创建的时候就相当于在内存中开辟空间，而案例中str和str1就是占用的两块不同的空间，所以他们的内存地址是不一致的，在用符号判断的时候就不相等了，即为false。
 
 也许你会这样子尝试：
 
 这个时候的输出结果就可能会让你感觉疑惑：
 
 这又是什么原因呢？是因为定义String str = "hello"和String str1 = "hello"没有进行对象的创建，而是同时指向的一个对象，所以他们的内存地址是相同的。
 
 问题来了，既然不能用，那我们应该用什么呢？
 在Java中判断两个字符串是否相等，需要使用equals方法；
 语法：字符串1.equals(字符串2) 如果字符串1等于字符串2返回true，否则返回false；
 例如：
 
 输出： str与str1是否相等true
 编程要求
 在右侧编辑器Begin-end处填充代码，实现在数组中查找指定字符串位置的功能。
 测试说明
 测试输入：张三
 预期输出：张三在数组的第1个位置
 测试输入：张富贵
 预期输出：张富贵在数组的第5个位置
 开始你的任务吧，祝你成功！
 参考代码：
 
package step2;
import java.util.Scanner;
public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//str为要查找的字符串
		String str = sc.next();
		/********** Begin **********/
		//创建数组   arr  给数组赋值 {"张三","张三丰","张无忌","王二麻子","张富贵"}
		String [] arr={"张三","张三丰","张无忌","王二麻子","张富贵"};
		    for(int i=0;i<arr.length;i++){
				if(arr[i].equals(str))
			 System.out.println(str+"在数组的第"+(i+1)+"个位置");}
		/********** End **********/
	}
}
 
第3关：交换算法
 任务描述
 本关任务：完成两个数（a与b）的交换。
 相关知识
 看到这个问题，也许你的第一想法就是：
 
int a = 3;
int b = 4;
a = b;
b = a;
System.out.println(a);
System.out.println(b);
 
问题真有那么简单吗？猜猜这段程序输出的结果吧！
 我们在之前的章节中提到过，变量就相当于一个杯子，每一个变量相当于不同的杯子，本关要完成的两个变量的交换，可以看做是将两个杯子中装的液体进行交换，请你思考一下如何将两个杯子中的液体交换呢？
 
 只有两个杯子能不能完成呢？
 如果是三个杯子呢？
 
 编程要求
 是时候检验一下啦，在右侧编辑器Begin-end中填充代码，完成两个变量的交换吧。
 测试说明
 测试输入：3，5
 预期输出：
 5
 3
 测试输入：4,2
 预期输出：
 2
 4
 开始你的任务吧，祝你成功！
 参考代码：
 
package step3;
import java.util.Scanner;
public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		/********** Begin **********/
		//将a的值赋给b   b的值赋给a
		int c;
		c=a;
		a=b;
		b=c;	
		/********** End **********/
		System.out.println(a);
		System.out.println(b);
	}
}
 
第4关：选择排序
 任务描述
 本关任务：实现数组从大到小的排序（降序排序）。
 相关知识
 为了解决数组排序的问题你需要先了解：选择排序。
 选择排序
 关于选择排序，你可以理解为一个循环打擂台的过程，还记得我们在上一章节中求数组中的最大值吗？
 
 我们运用打擂台的原理，可以求出数组中的最大值。
 核心代码：
 
int max = scores[0];
for (int i = 1; i < scores.length; i++) {
    if(max < scores[i]){    //求最大值
    max = scores[i];
    }
}
 
这样一轮循环之后我们就可以求出数组scores的最大值。
 第一轮擂台赛求出最大值之后，我们可以对接下来的数据再进行打擂台的操作，就出剩下数据的最大值（也就是第二大的值），以此类推，就可以实现数组从大到小的排序。
 实现过程
 为了实现选择排序，我们需要求出最大值，并且和相比较的数据交换位置：接下来我们对数组int[] arr = {6,5,8,0,2,9}来进行第一趟循环，将最大值移动到数组的第一位。
 
 代码实现：
 int[] arr = {6,5,8,0,2,9};
 for (int i = 0; i < arr.length-1; i++) {
 if(arr[0] < arr[i+1]){
 int temp = arr[0];
 arr[0] = arr[i+1];
 arr[i+1] = temp;
 }
 }
 一次循环操作就可以找出数组中的最大值，并将其移动到数组的首位，所以对于一个长度为6的数组，我们只需要进行5（length-1）次上述操作即可将数组降序排序了。
 接下来我们进行第二趟循环，求第二大的值，并将其移动到数组的第二个位置。因为我们已经求出了最大值，所以这一次循环，最大值不用参与比较。
 
 代码实现：
 
 结果：[9, 8, 5, 0, 2, 6]
 可以发现经过两轮循环我们找出了数组中最大的两个值，并且移动他们到了数组的前两位。
 现在按照上述步骤就可以实现数组的排序了，不过如果我们照搬上述代码，就会有很多冗余的代码，所以需要你来改进，怎么改进是需要你思考的。
 告诉你一个秘密：使用Arrays.toString(数组)可以直接输出数组中的值哦！
 如下：
 
 输出结果：[6, 5, 8, 0, 2, 9]
 思考题
 本关所讲述的选择排序是一个简化版本，如果你想要学习优化版可以根据下列图片，编写出相应代码，然后在评论区贴出来哦。
 
 上图就是一个使用选择排序将一个数组中数据从小到大排序的过程，请思考如何用代码实现上述过程。
 原理：每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
 本关难度较大，但这是学习数组绕不过去的一关，多思考，多尝试，你能成功的，加油！
 编程要求
 在右侧Begin-End区域中添加代码，实现对数组arr的降序排序，并输出排序后的arr数组。
 测试说明
 我会对你的程序进行测试；
 预期输入：6，6，5，0，2，8，9
 预期输出：[9, 8, 6, 5, 2, 0]
 预期输入：4，3，12，1，13
 预期输出：[13, 12, 3, 1]
 开始你的任务吧，祝你成功！
 参考代码：
 
package step4;
import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//动态创建数组
		int[] arr = new int[sc.nextInt()];
		for(int i = 0 ; i< arr.length ; i++){
			arr[i] = sc.nextInt();
		}
		/********** Begin **********/
		int max=arr[0];
		for(int i=0;i<arr.length;i++){
			if(max<arr[i]){
				max=arr[i];
			}
		}
		for(int i=0;i<arr.length-1;i++){
			if(arr[0]<arr[i+1]){
				int temp=arr[0];
				arr[0]=arr[i+1];
				arr[i+1]=temp;
			}
		}
		for(int i=1;i<arr.length-1;i++){
			if(arr[1]<arr[i+1]){
				int temp=arr[1];
				arr[1]=arr[i+1];
				arr[i+1]=temp;
			}
		}
		for(int i=2;i<arr.length-1;i++){
			if(arr[2]<arr[i+1]){
				int temp=arr[2];
				arr[2]=arr[i+1];
				arr[i+1]=temp;
			}
		}
		for(int i=3;i<arr.length-1;i++){
			if(arr[3]<arr[i+1]){
				int temp=arr[3];
				arr[3]=arr[i+1];
				arr[i+1]=temp;
			}
		}
		for(int i=4;i<arr.length-1;i++){
			if(arr[4]<arr[i+1]){
				int temp=arr[4];
				arr[4]=arr[i+1];
				arr[i+1]=temp;
			}
		}
		System.out.println(Arrays.toString(arr));
		/********** End **********/
	}
}
 
第5关：冒泡排序
 任务描述
 本关任务：使用冒泡排序实现数组的升序排序（从小到大）。
 相关知识
 冒泡排序
 
 看完上图，相信你已经能明白冒泡排序的原理了。
 将序列当中的左右元素，依次比较，如果左边的元素大于右边元素则交换位置，保证右边的元素始终大于左边的元素;( 第一轮结束后，序列最后一个元素一定是当前序列的最大值;)对序列当中剩下的n-1个元素再次执行步骤1。对于长度为n的序列，一共需要执行n-1轮比较。
 在代码中实现一轮比较：
 
 输出结果：[5, 8, 0, 2, 6, 9]
 编程要求
 在编辑器Begin-end处填充代码，使用冒泡排序对数组arr进行升序排序，最后输出排序之后数组arr中的数据。
 测试说明
 预期输入：6，9，5，8，0，2，6
 预期输出：[0, 2, 5, 6, 8, 9]
 预期输入：4，3，12，13，0
 预期输出：[0, 3, 12, 13]
 开始你的任务吧，祝你成功！
 参考代码：
 
package step5;
import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//动态创建数组
		int[] arr = new int[sc.nextInt()];
		for(int i = 0 ; i< arr.length ; i++){
			arr[i] = sc.nextInt();
		}
	   for(int i=0;i<arr.length-1;i++){
		   if(arr[i]>arr[i+1]){
			   int temp=arr[i];
			   arr[i]=arr[i+1];
			   arr[i+1]=temp;
		   }
	   }
	   for(int i=0;i<arr.length-2;i++){
		   if(arr[i]>arr[i+1]){
			   int temp=arr[i];
			   arr[i]=arr[i+1];
			   arr[i+1]=temp;
		   }
	   }
	   for(int i=0;i<arr.length-3;i++){
		   if(arr[i]>arr[i+1]){
			   int temp=arr[i];
			   arr[i]=arr[i+1];
			   arr[i+1]=temp;
		   }
	   }
	   for(int i=0;i<arr.length-4;i++){
		   if(arr[i]>arr[i+1]){
			   int temp=arr[i];
			   arr[i]=arr[i+1];
			   arr[i+1]=temp;
		   }
	   }
	   for(int i=0;i<arr.length-5;i++){
		   if(arr[i]>arr[i+1]){
			   int temp=arr[i];
			   arr[i]=arr[i+1];
			   arr[i+1]=temp;
		   }
	   }
	   for(int i=0;i<arr.length-6;i++){
		   if(arr[i]>arr[i+1]){
			   int temp=arr[i];
			   arr[i]=arr[i+1];
			   arr[i+1]=temp;
		   }
	   }
	  for(int i=0;i<arr.length-7;i++){
		   if(arr[i]>arr[i+1]){
			   int temp=arr[i];
			   arr[i]=arr[i+1];
			   arr[i+1]=temp;
		   }
	   }
		System.out.println(Arrays.toString(arr));
		/********** End **********/
	}
}	

第1关：数组的复制
 
任务描述
 
本关任务：完成将一个数组的值复制给另一个数组。
 
相关知识
 
本关需要你完成数组的复制操作，可以分三个步骤来实现。
 
 
创建一个数组arr2，数组长度和数组arr1相同；
 
 
使用循环将数组1中的每一个数据赋值给数组2中对应的那一项。（即arr2[0] = arr1[0]）；
 
 
循环输出复制之后arr2中的所有数据。
 
编程要求
 
在右侧编辑器Begin-End中填充代码，将arr1数组中的数据全部复制给arr2数组，最后输出arr2中所有的数据。
 
测试说明
 
我会对你的程序进行测试，如下： 测试输入：1，3，12 预期输出： 1 3 12 测试输入：2，13，11 预期输出： 2 13 11
 
package step1;

import java.util.Scanner;

public class HelloWorld {
	public static void main(String[] args) {
		//动态构建arr1
		int[] arr1 = new int[3];
		Scanner sc = new Scanner(System.in);
		for(int i = 0 ; i< arr1.length ; i++){
			arr1[i] = sc.nextInt();
		}
		/********** Begin **********/
		//创建数组arr2
        int[] arr2 = new int[arr1.length];

        //使用for循环将arr1的数据复制给arr2

        for (int j = 0; j < arr1.length; j++) {
            arr2[j] = arr1[j];
        }

        //输出arr2
        for (int array : arr2)
            System.out.println(array);
		/********** End **********/
	}
}
 
第2关：数组中元素的查找
 
任务描述
 
本关任务：完成查找字符串数组中指定字符串位置的小程序。
 
相关知识
 
为了完成本关任务，你需要知道：如何判断两个字符串是否相等。
 
如何判断字符串相等
 
我们之前判断两个数是否相等使用的是==符号，我们判断字符串是否相等能否用==符号呢？我们来看一段代码。
 
 
输出结果： 
 
为什么呢？ 是因为==比较的是两个对象的内存地址，我们知道变量被创建的时候就相当于在内存中开辟空间，而案例中str和str1就是占用的两块不同的空间，所以他们的内存地址是不一致的，在用==符号判断的时候就不相等了，即为false。
 
 
也许你会这样子尝试：
 
 
这个时候的输出结果就可能会让你感觉疑惑： 
 
这又是什么原因呢？是因为定义String str = "hello"和String str1 = "hello"没有进行对象的创建，而是同时指向的一个对象，所以他们的内存地址是相同的。
 
 
问题来了，既然==不能用，那我们应该用什么呢？
 
在Java中判断两个字符串是否相等，需要使用equals方法；
 
语法：字符串1.equals(字符串2) 如果字符串1等于字符串2返回true，否则返回false； 例如：
 
 
输出： str与str1是否相等true
 
编程要求
 
在右侧编辑器Begin-end处填充代码，实现在数组中查找指定字符串位置的功能。
 
测试说明
 
测试输入：张三 预期输出：张三在数组的第1个位置
 
测试输入：张富贵 预期输出：张富贵在数组的第5个位置
 
package step2;

import java.util.Scanner;

public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		//str为要查找的字符串
		String str = sc.next();
		
		/********** Begin **********/
		//创建数组   arr  给数组赋值 {"张三","张三丰","张无忌","王二麻子","张富贵"}
		String[] arr = {"张三", "张三丰", "张无忌", "王二麻子", "张富贵"};

        for (int i = 0; i < arr.length; i++) {
            int j = i + 1;
            if (str.equals(arr[i]))
                System.out.println(str + "在数组的第" + j + "个位置");
        }
		
		/********** End **********/
	}
}
 
第3关：交换算法
 
任务描述
 
本关任务：完成两个数（a与b）的交换。
 
相关知识
 
看到这个问题，也许你的第一想法就是：
 
 
 
int a = 3;
int b = 4;
a = b;
b = a;
System.out.println(a);
System.out.println(b);
问题真有那么简单吗？猜猜这段程序输出的结果吧！
 
我们在之前的章节中提到过，变量就相当于一个杯子，每一个变量相当于不同的杯子，本关要完成的两个变量的交换，可以看做是将两个杯子中装的液体进行交换，请你思考一下如何将两个杯子中的液体交换呢？
 
 
只有两个杯子能不能完成呢？
 
如果是三个杯子呢？
 
 
编程要求
 
是时候检验一下啦，在右侧编辑器Begin-end中填充代码，完成两个变量的交换吧。
 
测试说明
 
测试输入：3，5 预期输出： 5 3 测试输入：4,2 预期输出： 2 4
 
package step3;

import java.util.Scanner;

public class HelloWorld {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		/********** Begin **********/
		//将a的值赋给b   b的值赋给a
		
		int temp=a;
        a=b;
        b=temp;

		/********** End **********/
		System.out.println(a);
		System.out.println(b);
	}
	
}
 
第4关：选择排序
 
任务描述
 
本关任务：实现数组从大到小的排序（降序排序）。
 
相关知识
 
为了解决数组排序的问题你需要先了解：选择排序。
 
选择排序
 
关于选择排序，你可以理解为一个循环打擂台的过程，还记得我们在上一章节中求数组中的最大值吗？
 
 
我们运用打擂台的原理，可以求出数组中的最大值。 核心代码：
 
 
 
int max = scores[0];
for (int i = 1; i < scores.length; i++) {
if(max < scores[i]){ //求最大值
max = scores[i];
}
}
这样一轮循环之后我们就可以求出数组scores的最大值。 第一轮擂台赛求出最大值之后，我们可以对接下来的数据再进行打擂台的操作，就出剩下数据的最大值（也就是第二大的值），以此类推，就可以实现数组从大到小的排序。
 
实现过程
 
为了实现选择排序，我们需要求出最大值，并且和相比较的数据交换位置：接下来我们对数组int[] arr = {6,5,8,0,2,9}来进行第一趟循环，将最大值移动到数组的第一位。
 
 
代码实现：
 
 
 
int[] arr = {6,5,8,0,2,9};
 
for (int i = 0; i < arr.length-1; i++) {
if(arr[0] < arr[i+1]){
int temp = arr[0];
arr[0] = arr[i+1];
arr[i+1] = temp;
}
}
一次循环操作就可以找出数组中的最大值，并将其移动到数组的首位，所以对于一个长度为6的数组，我们只需要进行5（length-1）次上述操作即可将数组降序排序了。
 
接下来我们进行第二趟循环，求第二大的值，并将其移动到数组的第二个位置。因为我们已经求出了最大值，所以这一次循环，最大值不用参与比较。
 
 
代码实现：
 
 
结果：[9, 8, 5, 0, 2, 6]
 
可以发现经过两轮循环我们找出了数组中最大的两个值，并且移动他们到了数组的前两位。
 
现在按照上述步骤就可以实现数组的排序了，不过如果我们照搬上述代码，就会有很多冗余的代码，所以需要你来改进，怎么改进是需要你思考的。
 
告诉你一个秘密：使用Arrays.toString(数组)可以直接输出数组中的值哦！ 如下：
 
 
输出结果：[6, 5, 8, 0, 2, 9]
 
思考题
 
本关所讲述的选择排序是一个简化版本，如果你想要学习优化版可以根据下列图片，编写出相应代码，然后在评论区贴出来哦。
 
 
上图就是一个使用选择排序将一个数组中数据从小到大排序的过程，请思考如何用代码实现上述过程。
 
原理：每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
 

本关难度较大，但这是学习数组绕不过去的一关，多思考，多尝试，你能成功的，加油！
 
编程要求
 
在右侧Begin-End区域中添加代码，实现对数组arr的降序排序，并输出排序后的arr数组。
 
测试说明
 
我会对你的程序进行测试； 预期输入：6，6，5，0，2，8，9 预期输出：[9, 8, 6, 5, 2, 0]
 
预期输入：4，3，12，1，13 预期输出：[13, 12, 3, 1]
 
package step4;

import java.util.Arrays;
import java.util.Scanner;

public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//动态创建数组
		int[] arr = new int[sc.nextInt()];
		for(int i = 0 ; i< arr.length ; i++){
			arr[i] = sc.nextInt();
		}
		/********** Begin **********/
		for (int i = 0; i < arr.length - 1; i++) {
            int k = i;
            for (int j = k + 1; j < arr.length; j++) {
                if (arr[j] > arr[k]) {
                    k = j;
                }
            }
            if (i != k) {
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
        System.out.println(Arrays.toString(arr));	
		
		/********** End **********/
	}
}
 
第5关：冒泡排序
 
任务描述
 
本关任务：使用冒泡排序实现数组的升序排序（从小到大）。
 
相关知识
 
冒泡排序
 
 
看完上图，相信你已经能明白冒泡排序的原理了。
 
将序列当中的左右元素，依次比较，如果左边的元素大于右边元素则交换位置，保证右边的元素始终大于左边的元素;( 第一轮结束后，序列最后一个元素一定是当前序列的最大值;)对序列当中剩下的n-1个元素再次执行步骤1。对于长度为n的序列，一共需要执行n-1轮比较。
 
在代码中实现一轮比较：
 
 
输出结果：[5, 8, 0, 2, 6, 9]
 
编程要求
 
在编辑器Begin-end处填充代码，使用冒泡排序对数组arr进行升序排序，最后输出排序之后数组arr中的数据。
 
测试说明
 
预期输入：6，9，5，8，0，2，6 预期输出：[0, 2, 5, 6, 8, 9]
 
预期输入：4，3，12，13，0 预期输出：[0, 3, 12, 13]
 
package step5;

import java.util.Arrays;
import java.util.Scanner;

public class HelloWorld {
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//动态创建数组
		int[] arr = new int[sc.nextInt()];
		for(int i = 0 ; i< arr.length ; i++){
			arr[i] = sc.nextInt();
		}
		/********** Begin **********/
	    for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
		
		/********** End **********/
	}
}