精华内容
下载资源
问答
  • Java数组进阶了解

    2021-08-14 12:24:18
    这篇博客是基于上一篇博客的补充,完善一点关于Java数组的知识。如有错误欢迎指正。 一、数组 1.内存分配 1.1概述 内存是计算机中的重要原件,临时存储区域,作用是运行程序。我们编写的程序是存放在硬盘中...

    这篇博客是基于上一篇博客的补充,完善一点关于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数组进阶

    2021-04-19 22:16:15
    Java头歌闯关第一步 标题第1关:数组的复制 创建一个数组arr2,数组长度和数组arr1相同; 使用循环将数组1中的每一个数据赋值给数组2中对应的那一项。(即arr2[0] = arr1[0]); 循环输出复制之后arr2中的所有数据...

    Java头歌闯关第一步

    标题第1关:数组的复制

    1. 创建一个数组arr2,数组长度和数组arr1相同;
    2. 使用循环将数组1中的每一个数据赋值给数组2中对应的那一项。(即arr2[0] = arr1[0]);
    3. 循环输出复制之后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关:交换算法

    三种方法进行交换:引入第三者/异或/相加;

    1. int temp = a; //生成第三方临时变量temp,将a的值赋给它
      a = b;
      b = temp;
    2. a = a ^ b;
      b = a ^ b;
      a = a ^ b;
    3. 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));
    	}
    
    }
    
    展开全文
  • Java入门 - 数组进阶

    千次阅读 2021-01-15 10:36:14
    第1关:数组的复制 任务描述 本关任务:完成将一个数组的值复制给另一个数组。 相关知识 本关需要你完成数组的复制操作,可以分三个步骤来实现。 创建一个数组arr2,数组长度和数组arr1相同; 使用循环将数组1中的每...

    第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 **********/
    	}
    }	
    
    
    展开全文
  • EduCoder Java入门 - 数组进阶

    千次阅读 2021-02-10 21:11:13
    第1关:数组的复制 任务描述 本关任务:完成将一个数组的值复制给另一个数组。 相关知识 本关需要你完成数组的复制操作,可以分三个步骤来实现。 创建一个数组arr2,数组长度和数组arr1相同; 使用循环...

    第1关:数组的复制

    任务描述

    本关任务:完成将一个数组的值复制给另一个数组。

    相关知识

    本关需要你完成数组的复制操作,可以分三个步骤来实现。

    1. 创建一个数组arr2,数组长度和数组arr1相同;

    2. 使用循环将数组1中的每一个数据赋值给数组2中对应的那一项。(即arr2[0] = arr1[0]);

    3. 循环输出复制之后arr2中的所有数据。

    编程要求

    在右侧编辑器Begin-End中填充代码,将arr1数组中的数据全部复制给arr2数组,最后输出arr2中所有的数据。

    测试说明

    我会对你的程序进行测试,如下: 测试输入:1312 预期输出: 1 3 12 测试输入:21311 预期输出: 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关:数组中元素的查找

    任务描述

    本关任务:完成查找字符串数组中指定字符串位置的小程序。

    相关知识

    为了完成本关任务,你需要知道:如何判断两个字符串是否相等。

    如何判断字符串相等

    我们之前判断两个数是否相等使用的是==符号,我们判断字符串是否相等能否用==符号呢?我们来看一段代码。

    输出结果:

    为什么呢? 是因为==比较的是两个对象的内存地址,我们知道变量被创建的时候就相当于在内存中开辟空间,而案例中strstr1就是占用的两块不同的空间,所以他们的内存地址是不一致的,在用==符号判断的时候就不相等了,即为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关:交换算法

    任务描述

    本关任务:完成两个数(ab)的交换。

    相关知识

    看到这个问题,也许你的第一想法就是:

     
    1. int a = 3;
    2. int b = 4;
    3. a = b;
    4. b = a;
    5. System.out.println(a);
    6. System.out.println(b);

    问题真有那么简单吗?猜猜这段程序输出的结果吧!

    我们在之前的章节中提到过,变量就相当于一个杯子,每一个变量相当于不同的杯子,本关要完成的两个变量的交换,可以看做是将两个杯子中装的液体进行交换,请你思考一下如何将两个杯子中的液体交换呢?

    只有两个杯子能不能完成呢?

    如果是三个杯子呢?

    编程要求

    是时候检验一下啦,在右侧编辑器Begin-end中填充代码,完成两个变量的交换吧。

    测试说明

    测试输入:35 预期输出: 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关:选择排序

    任务描述

    本关任务:实现数组从大到小的排序(降序排序)。

    相关知识

    为了解决数组排序的问题你需要先了解:选择排序。

    选择排序

    关于选择排序,你可以理解为一个循环打擂台的过程,还记得我们在上一章节中求数组中的最大值吗?

    我们运用打擂台的原理,可以求出数组中的最大值。 核心代码:

     
    1. int max = scores[0];
    2. for (int i = 1; i < scores.length; i++) {
    3. if(max < scores[i]){ //求最大值
    4. max = scores[i];
    5. }
    6. }

    这样一轮循环之后我们就可以求出数组scores的最大值。 第一轮擂台赛求出最大值之后,我们可以对接下来的数据再进行打擂台的操作,就出剩下数据的最大值(也就是第二大的值),以此类推,就可以实现数组从大到小的排序。

    实现过程

    为了实现选择排序,我们需要求出最大值,并且和相比较的数据交换位置:接下来我们对数组int[] arr = {6,5,8,0,2,9}来进行第一趟循环,将最大值移动到数组的第一位。

    代码实现:

     
    1. int[] arr = {6,5,8,0,2,9};
    2.  
    3. for (int i = 0; i < arr.length-1; i++) {
    4. if(arr[0] < arr[i+1]){
    5. int temp = arr[0];
    6. arr[0] = arr[i+1];
    7. arr[i+1] = temp;
    8. }
    9. }

    一次循环操作就可以找出数组中的最大值,并将其移动到数组的首位,所以对于一个长度为6的数组,我们只需要进行5(length-1)次上述操作即可将数组降序排序了。

    接下来我们进行第二趟循环,求第二大的值,并将其移动到数组的第二个位置。因为我们已经求出了最大值,所以这一次循环,最大值不用参与比较。

    代码实现:

    结果:[9, 8, 5, 0, 2, 6]

    可以发现经过两轮循环我们找出了数组中最大的两个值,并且移动他们到了数组的前两位。

    现在按照上述步骤就可以实现数组的排序了,不过如果我们照搬上述代码,就会有很多冗余的代码,所以需要你来改进,怎么改进是需要你思考的。

    告诉你一个秘密:使用Arrays.toString(数组)可以直接输出数组中的值哦! 如下:

    输出结果:[6, 5, 8, 0, 2, 9]

    思考题

    本关所讲述的选择排序是一个简化版本,如果你想要学习优化版可以根据下列图片,编写出相应代码,然后在评论区贴出来哦。

    上图就是一个使用选择排序将一个数组中数据从小到大排序的过程,请思考如何用代码实现上述过程。

    原理:每一次从待排序的数据元素中选出最小的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。


    本关难度较大,但这是学习数组绕不过去的一关,多思考,多尝试,你能成功的,加油!

    编程要求

    在右侧Begin-End区域中添加代码,实现对数组arr的降序排序,并输出排序后的arr数组。

    测试说明

    我会对你的程序进行测试; 预期输入:6650289 预期输出:[9, 8, 6, 5, 2, 0]

    预期输入:4312113 预期输出:[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中的数据。

    测试说明

    预期输入:6958026 预期输出:[0, 2, 5, 6, 8, 9]

    预期输入:4312130 预期输出:[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 **********/
    	}
    }	
    

     

    展开全文
  • 数组进阶

    2018-09-22 21:09:10
    数组的搜索算法 数组的搜索算法:从指定数组中去搜索某一个元素的索引是多少. 方式1:线性搜索(从头搜到尾/从尾搜到头):indexOf/lastIndexOf 对于元素过多的数组,性能极低:有N个元素,循环次数= (N + 1) / 2; 方式2:二...
  • 第1关:数组的复制 1、编程要求:  在右侧编辑器Begin-End中填充代码,将arr1数组中的数据全部复制给arr2数组,最后输出arr2中所有的数据。 2、测试效果:  我会对你的程序进行测试,如下:  测试输入:1,3,12 ...
  • 引言: 笔者在学习Java数据结果跟算法的过程中,知道数组在数据结构跟算法中是很中烟的存在,只要对数组有相当的认知以后才能说自己对这一模块才能说熟悉掌握,单反在任何语言当中,学习用本质看现象才能更好的去...
  • 数组算法 升序,引入一个工具 知识 如何导入工具类 import 工具类的路径 例子 import java.util.Arrays; 使用工具 sort方法 帮我们把数组进行升序,由小到大 会影响数组内部的结构 用法 Arrays....
  • 十、数组进阶

    2021-05-28 20:00:37
    第1关:数组的复制 任务描述 本关任务:完成将一个数组的值复制给另一个数组。 相关知识 本关需要你完成数组的复制操作,可以分三个步骤来实现。 创建一个数组arr2,数组长度和数组arr1相同; 使用循环将数组1中...
  • 变量交换和数组算法 变量交换 方法一,引用第三个变量 public class 方法一 { public static void main(String[]args){ String a="a"; String b="b"; String temp; System.out.println("交换前a:...
  • 1 选择排序:采用多轮扫描数组,每轮选择最小的与前面 的元素交换。每轮可以找到一个最小的,最后一个元素不 需要处理。 3 | 4 1 5 8 2 9 一 1 | 4 3 5 8 2 9 二 1 2 | 4 5 8 3 9 三 1 2 3 | 5 8 4
  • 关于博主 努力与运动兼备~~~有任何问题可以加我好友或者关注微信公众号,欢迎交流,我们一起进步! 微信公众号: 啃饼思录 ...因为我们上篇实现的数组只能存放int类型,但是我们需要的是可以承载多种...
  • 老寇云-java技术栈进阶-武侠篇-java数组越界(文章持续调优中)
  • java数组算法

    2019-03-11 23:27:35
    1.给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。不要使用额外的数组空间,你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 输入[0,0,1,1,1,...
  • 排序算法: ...例如:java中提供了一个数组工具类: java.util.Arrays Arrays是一个工具类。其中有一个sort()方法,可以排序。静态方法,直接使用类名调用就行。 冒泡排序 参与比较的数据:9 8 10 7 6 0
  • Java数组

    2021-03-19 18:06:38
    Java数组 数组概述 数组声明创建 数组使用(重点) 多维数组 Arrsys类 稀疏数组(简单数据结构)
  • Java数组要求所有数组元素具有相同的类型。在一个数组中,数组元素类型是唯一的,只能储存同一种数据类型,不能出现多种数据类型。 定义数组 定义数组的方式有两种: type[] arrayName type arrayName[] 推荐...
  • JAVA数组的介绍与使用 一、概述 1.1 定义 数组是一种数据结构,用来存储同一类型值的集合。简单说,就是一个存放同种类型的容器。 数组是指一组数据的集合,数组中的每个数据称为元素。但同一个数组里只能存放类型...
  • java数组

    2021-08-17 18:52:14
    数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据,按照一定的先后顺序排列组成而成 每一个数组称作一个数组元素,每个数组元素可以通过一个下表来访问他们 数组声明创建 必须声明数组...
  • /* 问题:用户手动输入一个数n,然后手动依次录入n数据,录入完成 输出最大值和最小值 思路: 步骤一:根据用户录入的数据开辟对应的数组空间 步骤二:利用循环语句让用户一次录入数据,并用...import java.util.Sca...
  • 算法 计算机科学数学中的基本算法(离散数学) 1.数组中最长的递增子序列在最长增加子序列(LIS)问题中,找到给定序列的最长子序列的长度,以使该子序列的所有元素都按升序排序 Ex: Input : arr[] = {3, 10, 2,...
  • 10.java数组

    2021-08-12 13:41:52
    java数组一级目录二级目录三级目录 数组的概念: 一种容器,可以同时存放多个数据值。 数组的特点: 数组是一种引用数据类型。 数组当中有多个数据,数据类型必须统一。 数组的长度在程序运行期间不可以改变。 数组...
  • java中的数组是什么? 在我看来,java中的数组可以理解为是一个没有物理class类, 但是可实例化对象且有自己类型的一个对象,并且是Object的子类。 或者说java中的数组除了没有对应的class文件和不可继承外,和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,806
精华内容 6,722
关键字:

java数组进阶算法

java 订阅