精华内容
下载资源
问答
  • 题目: 假定本学期某班上有5门课,该班上有10人 (1) 请输入该班同学的学号,姓名,5门课的成绩至数组A、B中,再按5门课的总分排序,然后列出排序后的序号,学号,姓名,成绩1~5; (2) 求出5门课的平均成绩
  • Java 多维数组排序

    2018-05-29 15:49:00
    Java 多维数组 按某列 排序 转载于:https://www.cnblogs.com/qlky/p/9105430.html

    Java 多维数组 按某列 排序

     

    转载于:https://www.cnblogs.com/qlky/p/9105430.html

    展开全文
  • 有一个二维数组,我想按照第一,第二,第三列进行降序排列。 注意: 1、如果第一列数值相同,那么就按照第二列降序排列。 2、同理,如果第二列数值相同,那么就按照第三列降序排列。 代码如下: import ...

    版权声明

    本博文首发于:
    CSDN 瑾兰https://blog.csdn.net/qq_28296925) 博客。
    请注意:
    无需授权即可转载;
    甚至无需保留以上版权声明… …


    情景:

    有一个二维数组,我想按照第一,第二,第三列进行降序排列。

    注意:
    1、如果第一列数值相同,那么就按照第二列降序排列。
    2、同理,如果第二列数值相同,那么就按照第三列降序排列。


    代码如下:

    import java.util.Comparator;    
          
      public class ArraySort {    
          
          public static void sort(int[][] ob, final int[] order) {    
              Arrays.sort(ob, new Comparator<Object>() {    
                  public int compare(Object o1, Object o2) {    
                      int[] one = (int[]) o1;    
                      int[] two = (int[]) o2;    
                      for (int i = 0; i < order.length; i++) {    
                          int k = order[i];    
                          if (one[k] < two[k]) {    
                              return 1;    
                          } else if (one[k] > two[k]) {    
                              return -1;    
                          } else {    
                              continue;  //如果按一条件比较结果相等,就使用第二个条件进行比较。  
                          }    
                      }    
                      return 0;    
                  }    
              });   
          }    
          
          public static void main(String[] args) {    
              int array[][] = new int[][] {     
                      { 12, 34, 68, 32, 9, 12, 545 },     
                      { 34, 72, 82, 57, 56, 0, 213 },     
                      { 12, 34, 68, 32, 21, 945, 23 },     
                      { 91, 10, 3, 2354, 73, 34, 18 },    
                      { 12, 83, 189, 26, 27, 98, 33 },     
                      { 47, 23, 889, 24, 899, 23, 657 },     
                      { 12, 34, 68, 343, 878, 235, 768 },     
                      { 12, 34, 98, 56, 78, 12, 546 },     
                      { 26, 78, 2365, 78, 34, 256, 873 } };    
                       //先根据第一列比较,若相同则再比较第二列,若第二列相同,则比较第三列
              sort(array, new int[] {0,1,2});  
              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.print("\t");    
                  }    
                  System.out.println();    
              }    
          }    
      }
    
    
    注意:

    1、如果想要升序排列,需要将sort()方法for()循环中的if判断修改一下。如下:

    if (one[k] >two[k]) {    
              return 1;    
    } else if (one[k] < two[k]) {    
                return -1;    
    } else {    
           continue;  //如果按一条件比较结果相等,就使用第二个条件进行比较。  
    }    
    

    2、如果想要按照某几列进行排序,则需要修改sort()中的第二个参数final int[] order
    比如,想要按照第一列,第三列进行排序。则如下:

    sort(array,new int{0,2})
    

    注意sort,第一个参数为进行排序的二维数组。


    参考链接:
    1、Java 多维数组 按某列 排序
    2、Java entry

    展开全文
  • Java多维数组分别进行行排列 一维数组的行排列 在进行一维数组排列时,只需要使用Arrays.sort()方法即可。 int[] a=new int[15,10,20,35,41]; Arrays.sort(a); 代码结果为: 10,15,20,35,41 二维数组的行排列 int...

    一维数组的行排列

    在进行一维数组排列时,只需要使用Arrays.sort()方法即可。

    int[] a=new int[15,10,20,35,41];
    Arrays.sort(a);
    

    代码结果为:

    10,15,20,35,41
    

    二维数组的行排列

     int[][] arrays=new int[2][3];
            for(i=0;i<2;i++)
            {
                for(j=0;j<3;j++)
                {
                    arrays[i][j]=(int)(Math.random()*100);
                    System.out.print("arrays["+i+"]["+j+"]="+arrays[i][j]+" ");
                }
                System.out.println();
            }
            Arrays.sort(arrays[0]);
            Arrays.sort(arrays[1]);
    

    这里采用Math的random方法为每一个元素进行赋值。
    :random()方法的取值范围为[0,1)。并且random()方法的返回值为double类型。若数组为int,则需要使用强制类型转换符。

    由于数组元素都是从下标0开始,所以对二维数组第一行排列使用Arrays.sort(arrays[0]) 方法;
    同理第二行排列使用 Arrays.sort(arrays[1])

    多维数组的行排列

    同理,与二维数组进行行排列方式一样。

    二维数组代码示例:

    package Example01;
    import java.util.Arrays;
    
    public class SortArrays {
        public static void main(String[] args) {
            int i,j;
            int[][] arrays=new int[2][3];
            for(i=0;i<2;i++)
            {
                for(j=0;j<3;j++)
                {
                    arrays[i][j]=(int)(Math.random()*100);  //采用random()方法对数组进行赋值
                    System.out.print("arrays["+i+"]["+j+"]="+arrays[i][j]+" ");
                }
                System.out.println();
            }
            
            Arrays.sort(arrays[0]); //对第一行元素进行排列
            Arrays.sort(arrays[1]); //对第二行元素进行排列
            
            for(i=0;i<2;i++)
            {
                if(i==0) System.out.println("第一行元素从小到大为:");
                else System.out.println("第二行元素从小到大为:");
                for(j=0;j<3;j++)
                {
                    System.out.print("arrays["+i+"]["+j+"]="+arrays[i][j]+" ");
                }
                System.out.println();
            }
        }
    }
    
    

    输出结果为:

    arrays[0][0]=87 arrays[0][1]=37 arrays[0][2]=39 
    arrays[1][0]=66 arrays[1][1]=58 arrays[1][2]=41 
    第一行元素从小到大为:
    arrays[0][0]=37 arrays[0][1]=39 arrays[0][2]=87 
    第二行元素从小到大为:
    arrays[1][0]=41 arrays[1][1]=58 arrays[1][2]=66 
    
    展开全文
  • java多维数组详解

    2020-11-12 18:52:41
    java中其实没有多维数组的概念,只不过是依据数组的概念以及特点技术上的延伸 本质上就是存储数组的数组 多维的数组的使用 ①声明 // ### ①声明 // 1)数据类型 [][] 数组名; // 创建一个存储整数类型数组 ...

    多维数组

    在java中其实没有多维数组的概念,只不过是依据数组的概念以及特点技术上的延伸

    本质上就是存储数组的数组

    多维的数组的使用

    在这里插入图片描述

    ①声明

    		// ### ①声明
    		// 1)数据类型 [][] 数组名;
    		// 创建一个存储整数类型数组 的 数组 名为arr1
    		int[][] arr1;
    		// 2)数据类型 数组名[][]
    		// 创建一个存储整数类型数据的 名为arr2 的数组中存储数组
    		int arr2[][];
    

    ②创建

    		// ### ②创建
    		// 1)动态创建
    		// 多维数组创建与普通数组不同的是,普通数组创建时必须指定长度
    		// 多维数组也是必须指定长度,但是可以先不指定里层数组长度
    		// 多维数组就是将原来存储数据的块改为存储数组
    		// 前面的长度必填,代表当前数组存储数据的个数
    		// 后面的长度可以先不填,但是在使用时必须创建相应长度数组存储,代表存储的数组可以存储数据的个数
    		arr1 = new int[3][4];
    		// {0,0,0,0}
    		// {0,0,0,0}
    		// {0,0,0,0}
    
    		// 2)静态创建
    		int arr3[][] = { { 1, 2, 3, 4 }, { 4, 5, 6, 7 }, { 7, 8, 9, 10 } };
    		// 不论是静态创建还是动态创建每块保存数组的长度可以不同
    		int arr4[][] = { { 1 }, { 4, 5 }, { 7, 8, 9 } };
    

    ③赋值

    // ### ③赋值
    		// 数组赋值只有一种通过数组名[下标]的形式进行赋值
    		arr3[0] = new int[1];// 注意现在存储的数据为数组那么赋值的数据也应该为数组
    		// 对于多维数组通常使用两个索引进行数据的定位数组名[行][列]
    		arr3[1][2] = 2;
    		System.out.println(arr3[1][2]);
    

    ④使用

    		// ### ④使用
    		// 与赋值相同
    		// 本质上使用与一维数组一样,但是由于其存储数据的形式与一维数组不同所以语法上也存在不同
    		// 数组名[取出数据所在数组索引索引][取出数据在其数组索引]
    
    		int [] a=new int[2];
    		int [][] b=new int[2][2];
    

    冒泡排序算法

    算法:

    算法可以理解为完成某一需求的过程(最简洁)

    完成需求的思路

    冒泡排序算法

    将指定的数据通过交换依次向后输送

    	// 冒泡排序
    	public static void main(String[] args) {
    		int[] arr = { 3, 7, 6, 2, 4, 1, 8, 9, 5 };
    		// 将数据两两比较(当前位与后一位比较)
    		// 如果后一位较大则交换依次进行
    
    		// arr[0]=>arr[1];
    		// arr[1]=>arr[2];
    		// arr[2]=>arr[3];
    		// arr[i]=>arr[i+1];
    		// 当比较到最后一位时i+1会越界 所以i的范围应为0~最大索引-1
    		for (int i = 0; i < arr.length - 1 - 1; i++) {
    			if (arr[i] > arr[i + 1]) {
    				int tmp = arr[i];
    				arr[i] = arr[i + 1];
    				arr[i + 1] = tmp;
    			}
    		}
    		// 执行一轮只能确定一位最值 根据长度需要执行length-1次
    		for (int j = 0; j < arr.length - 1; j++) {
    			for (int i = 0; i < arr.length - 1 - 1; i++) {
    				if (arr[i] > arr[i + 1]) {
    					int tmp = arr[i];
    					arr[i] = arr[i + 1];
    					arr[i + 1] = tmp;
    				}
    			}
    		}
    		// 在内存进行判断时每次都会判断到最后但每次执行最后已经判断过的最值不应该继续判断
    		// 每次判断时应将内层条件 随着外层修改而修改 修改范围应为arr.length - 1 - 1-j(外层循环次数)
    		// 外层每每循环一次就会确定一个最值 那么在内层判断时就可以少判断一个
    		for (int j = 0; j < arr.length - 1; j++) {
    			for (int i = 0; i < arr.length - 1 - 1 - j; i++) {
    				if (arr[i] > arr[i + 1]) {
    					int tmp = arr[i];
    					arr[i] = arr[i + 1];
    					arr[i + 1] = tmp;
    				}
    			}
    		}
    
    		// for (int j = 0; j < arr.length - 1; j++) {
    		// for (int i = 0; i < arr.length - 1 - j; i++) {
    		// if (arr[i] > arr[i + 1]) {
    		// int tmp = arr[i];
    		// arr[i] = arr[i + 1];
    		// arr[i + 1] = tmp;
    		// }
    		// }
    		// }
    
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i] + " ");
    		}
    	}
    

    java面向对象——封装

    封装的概念可以理解为打包,将程序进行一定程度的封装既能提高程序维护的效率也能提高程序的安全性

    java中的封装

    方法:

    将执行的多条语句以一个代码块进行封装并指定名称与运行时需要的数据,在需要使用时进行调用,隐藏了执行的过程,调用方只需要知道方法名以及传入指定参数就可以获取结果,并可以重复调用,既提高了系统的安全性也提高了系统开发维护的方便

    类:

    将一群具有相同特征相同行为对象相同进行抽取封装为类。可以用类来表示这些拥有共同属性的任意对象。

    属性:

    在类的定义过程中使用访问权限修饰符修饰属性,将属性权限设置为只对指定位置可见以提高系统的安全性。

    访问权限修饰符

    java中的封装只的就是使用访问权限修饰符对类、方法、属性进行修饰以达到安全性的体现

    在这里插入图片描述

    public:所有的类都能有public访问说明符。你能从任何Java程序的任何对象里使用公有类、成员数据(属性)和方法。
    private:只有本类的类对象才能访问的私有变量或方法,类内部成员之间可以访问;
    protected:在类中被声明为保护的变量,方法能被其子类访问。
    默认:(default)假如没有规定访问说明符,那就是friendly的。拥有友元访问符的类、变量或方法对包里的所有类来说都是可访问的。

    说明:在方法中的变量不能有访问说明符,因为该变量只能在该方法中使用,外界无法访问。

    使用限制

    访问权限修饰符可以用来修饰类、方法、属性但有一定的限制

    修饰类

    使用访问权限修饰类时只能使用public与默认修饰符

    package com.yunhe.day1016;
    //修饰类只能使用public或默认
    public class ASD {
    }
    
    package com.yunhe.day1016;
    //同包下其他类可以直接使用无需导包
    public class Test {
    	public static void main(String[] args) {
    		ASD asd=new ASD();
    	}
    }
    
    package com.yunhe.day1015;
    import com.yunhe.day1016.ASD;
    //不同包下需要导包才可以使用
    public class T1 {
    public static void main(String[] args) {
    	ASD asd=new ASD();
    }
    }
    

    默认访问权限修饰符修饰的类只有同包下可以使用其他包下不能访问

    修饰方法

    可以使用全部修饰符(常用public、private)

    修饰属性

    可以使用全部修饰符(常用private)

    私有属性赋值方法

    1)构造方法初始化赋值

    2)创建公开的方法进行修改

    由于方法的特性以及类的特性封装使用不是很多,所以现在一般封装指的就是属性的封装

    封装,就是隐藏实现细节
    将属性私有化,提供公有方法访问私有属性
    通过这些公有方法访问私有属性

    封装的实现

    1、修改属性的可见性来限制对属性的访问
    2、为每个属性创建一对赋值(setter)方法和取值(getter) 方法,用于对这些属性的访问
    3、在setter和getter方法中,加入对属性的存取限制

    学习完封装之后类的书写规范

    //类的属性规范
    //类修饰符根据实际使用决定使用public还是默认
    public class Teacher {
    	// 属性
    	// 所有属性使用private修饰
    	private String name;// 名字
    
    	// 为所有属性提供公开的getter与setter方法
    	// getter方法书写规范
    	// 修饰符必须为public 返回值类型与属性类型一致 方法名为get+属性名(遵循驼峰命名法)
    	public String getName() {
    		return name;
    	}
    
    	// setter方法书写规范
    	// 修饰符必须为public 返回值为void 方法名为set+属性名(遵循驼峰命名法)
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	// 构造方法
    	// 1无参构造方法
    	public Teacher() {
    	}
    
    	// 2全参构造方法
    	public T
    		this.name = name;
    	}
    }
    
    展开全文
  • java 多维数组排序问题 这里给出一道例题 假定本学期某班上有5门课,该班上有10人 (1) 请输入该班同学的学号,姓名,5门课的成绩至数组A、B中,再按5门课的总分排序,然后列出排序后的序号,学号,姓名,成绩1~5; ...
  • * 多维数组求每行最大值 */ import java.util.Arrays; public class ArraysDemo{ public static void main(String[] args) { //创建一个多维数组并赋值 int[][] arr = {{7,6,48,108,85},{1,7,66,545,78,56}}...
  • 二维数组排序

    2013-09-29 17:01:09
    // 二维数组冒泡排序 public static void main(String[] args) { int i=0, j=0, temp = 0; int[][] nums1 = { { 34, 1, 22, 5 }, { 28, 98, 15, 32 }, { 33, -5, 17, 41 } }; int rows = nums1.length; //二维...
  • 刚学习Java一个月,对于没东西不是很熟悉,今天在刷题时候时候,需要对多维数组中的一维进行升序/降序排列,思考到这个问题,开始百度学习如何解决!!! 常用类Arrays中有个sort()方法,可以对数组进行默认的升序...
  • import java.util.Arrays; public class HelloWorld { public static void main(String []args) { int[][] m = {{1,2,3,5},{22,0},{100,200}}; int[] n; int len=0; for(int[] element : m ){ len+=...
  • php 多维数组自定义排序 Everyone has probably been asked, "Which (food / movie / dress / whatever) do you like better, A or B?" Really, there's only three ways to answer this type of questio...
  • 二维数组排序,按照某一列列大小对数组进行排序。二维数组的排序直接调用Arrays.sort(); 虽然不会出现编译错误,但运行时会出现以下错误提示: 说明不可以这样用,而我们又想对它排序,就可以使用Comparator来外部...
  • 最近在一些练习之中遇到了很多关于二维数组的处理,例如二维数组的排序,找最大最小值之类的,所以现在来对二维数组或者可以说对多维数组,来做一个小小的总结。  其实无论是面对二维数组还是多维数组时都应该树立...
  • 数组前言1、数组的创建1.1 、动态初始化创建数组1.2 、静态初始化创建数组2、数组的遍历2.1、数组的遍历(1)2.2、数组的遍历(2)3、数组的练习4、存储引用变量5、多维数组 前言 数组的定义:在内存中一段连续的...
  • JAVA多维数组的使用及常见算法! 1 多维数组概述 Java 语言里提供了支持多维数组的语法。 如果说可以把一维数组当成几何中的线性图形, 那么二维数组就相当于是一个表格,像右图Excel 中的表格一样。 对于二维数组...
  • java数组这一节会说的比较多 数组可以说是很基础的一种结构了 比如python 有列表 元组 字典对吧,其实都可以看成一种数组嘛 pytorch的张量也可以看成数组java数组格式我觉得有点像c语言 毕竟java是取了c++...
  • 数组的元素类型和数组的大小都是确定的,所以当处理数组元素时候,我们通常使用基本循环或者 foreach 循环。下面实例完整地展示了如何创建、初始化和操纵数组:public class TestArray { public static void main...
  • 在其他地方你可能经常会看到一些关于java的数组排序,大多数写的都是同一种数据类型的数组排序,例如统一为整数的数组... 可以满足于一维、二维、多维数组排序 封装类,随调随用 先新建一个包含主方法的类:Main....
  • // 对第2类排序 /* Arrays.sort(array, new Comparator() { @Override public int compare(int[] o1, int[] o2) { return o1[0] - o2[0]; } }); Arrays.sort(array, new Comparator() { @Override public int ...
  • java 多维数组

    2021-08-29 15:30:10
    1. 多维数组概述 数组:它是一个线性数据结构,用于存储一组相同数据类型的数据(长度一经定义不可变)。 需求:存储 1 个班的 5 名同学的成绩。 double[] scores = new double[5]; scores[0] = 90; // .... ...
  • java stream 处理多维数组时的理解

    千次阅读 2017-07-13 19:38:09
    但 Stream 只提供一个管道,因此,当处理多维数组时,Stream 仍然 按照 单维数组 时那样处理,每一行视作一个元素传递,最后输出的仍然是一行元素,像从一个管道里放出来的一样。 可以用 flatMap 将多维数组...
  • 1.多维数组 多维数组的元素又是数组,可以有二维、三维、甚至更多维数组 1.1二维数组的声明: 数据类型 [][] = new 数据类型[一维长度][二维长度]public 1.2 二维数组的初始化:(动态初始化和静态初始化)public ...
  • [#### 数组、多维数组,静态、动态初始化,都说明白了] 什么是数组 所谓数组,是具有相同数据类型的若干变量或者数据按照一定排序规则组合起来的一种数据存储格式。数组中的数据称为数组元素,我们使用索引来标识...
  • 数组排序:通过sort方法,按升序 比较数组:通过equals方法比较数组中元素值是否相等 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作 冒泡排序: 两层循环,外层冒泡轮数,里层依次比较,...
  • java多维数组

    2021-08-13 14:07:25
    1.多维数组概述 数组:他是一个线性数据结构,用语存储一组相同数据类型的数据(长度一经定义不可变)。 需求:存储 1 个班的 5 名同学的成绩。 double[] scores = new double[5]; scores[0] = 90; // ... ...
  • 思路以及注意点、说明我都加在了代码旁边的注释里,好好悟悟!
  • 数组 1.形式 数组类型:类型 int[] 声明:类型+变量名,int[] nums 创建:分配数组长度,nums = int[10],数组对象是在堆中的。 总结:int[] nums = new int[10]; 或 int nums[] = new int[10];,多用前者。...
  • Java_13:多维数组-源码

    2021-05-18 16:59:05
    Learn_core_java_day_13 ...第13天:多维数组 第14天:ArrayList和集合 第15天-排序和搜索 第16天:例外 第17天:文件输入/输出 第18天:使用Java Swing进行GUI编程 第19天:接口和继承。 第20天:Web服务
  • 多维数组转一维,感谢提问的老师(达者为师),长时间不写了竟然一时没想到方法,思考了下,做个记录。 package com.test; import java.lang.reflect.Array; import org.testng.annotations.Test; public class...
  • 文章目录Java数组1、数组声明创建与初始化2、内存分析3、多维数组4、Arrays类5、冒泡排序 面试常遇见6、稀疏数组 重点 压缩数组7、二分查找法(折半查找法) 面试常见 Java数组 数组是相同类型数据的有序集合。每个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,334
精华内容 4,533
关键字:

java多维数组排序

java 订阅