精华内容
下载资源
问答
  • java数组排序

    2017-09-04 11:39:37
    java数组排序的思想,过程和代码实现。多种数组排序的方法,主要有冒泡排序,堆排序,插入排序, 归并操作(merge), 归并操作(merge),选择排序,希尔排序。
  • import java.lang.*;import java.util.*;public class Main {public static void main(String args[]) {int a[] = new int[]{1, 4, 612, 333, -8, 2, -12, 4534, 0};for (int i = 0; i < a.length; i++) { //直接...

    import java.lang.*;

    import java.util.*;

    public class Main {

    public static void main(String args[]) {

    int a[] = new int[]{1, 4, 612, 333, -8, 2, -12, 4534, 0};

    for (int i = 0; i < a.length; i++) { //直接选择排序(两重for循环排序)

    for (int j = i + 1; j < a.length; j++) {

    if (a[i] > a[j]) {

    int temp = a[j];

    a[j] = a[i];

    a[i] = temp;

    }

    }

    }

    for (int i = 0; i < a.length; i++)

    System.out.print(a[i] + "\t");

    System.out.println();

    }

    }

    运行结果

    -12 -8 0 1 2 4 333 612 4534

    2. java数组排序sort排序

    Arrays 是java的util包下的数组工具类,其中提供默认的sort排序.

    public class Main {

    public static void main(String args[]) {

    int[] arr = {1, 4, 612, 333, -8, 2, -12, 4534, 0};

    Arrays.sort(arr); //默认从小到大进行sort()排序

    for (int i = 0; i < arr.length; i++)

    System.out.print(arr[i] + "\t");

    System.out.println();

    }

    }

    结果

    -12 -8 0 1 2 4 333 612 4534

    3. javasort降序排序

    可以将升序的数组倒序输出,即可实现降序排序了。

    或者实现一个自己的数组反转方法.

    public class Main {

    public static void main(String args[]) {

    int[] arr = {1, 4, 612, 333, -8, 2, -12, 4534, 0};

    Arrays.sort(arr); //默认从小到大进行sort()排序

    // 逆序输出

    for (int i = arr.length - 1; i >= 0; i--)

    System.out.print(arr[i] + "\t");

    System.out.println();

    }

    }

    结果

    4534 612 333 4 2 1 0 -8 -12

    展开全文
  • Java数组排序

    千次阅读 2021-02-26 21:24:19
    当然可以自己编写合适的排序方法,但既然java包里有自带的Arrays.sort排序方法,在 数组元素比较少的时候为何不用?Sorting an Array 1. 数字排序 int[] intArray = new int[] { 4, 1, 3, -23 };Arrays.sort...

    有的时候需要对数组里的element进行排序。当然可以自己编写合适的排序方法,但既然java包里有自带的Arrays.sort排序方法,在 数组元素比较少的时候为何不用?

    Sorting an Array 1. 数字排序  int[] intArray = new int[] { 4, 1, 3, -23 };

    Arrays.sort(intArray);

    输出: [-23, 1, 3, 4]

    2. 字符串排序,先大写后小写 String[] strArray = new String[] { "z", "a", "C" };

    Arrays.sort(strArray);

    输出: [C, a, z]

    3. 严格按字母表顺序排序,也就是忽略大小写排序 Case-insensitive sort

    Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

    输出: [a, C, z]

    4. 反向排序, Reverse-order sort

    Arrays.sort(strArray, Collections.reverseOrder());

    输出:[z, a, C]

    5. 忽略大小写反向排序 Case-insensitive reverse-order sort

    Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

    Collections.reverse(Arrays.asList(strArray));

    输出: [z, C, a]

    java初学者最常见的错误思想,就是试图去写一些方法来完成数组的排序功能,其实,数组排序功能,在java的api里面早已实现,我们没有 必要去重复制造轮子。

    Arrays类有一个静态方法sort,利用这个方法我们可以传入我们要排序的数组进去排序,因为我们传入的是一个数组的引用,所以排序完成的 结果也通过这个引用的来更改数组.对于整数、字符串排序,jdk提供了默认的实现,如果要对一个对象数组排序,则要自己实现 java.util.Comparator接口。

    package com.gjh.gee.arrays;

    import java.util.Arrays;

    public class ArraySortDemo {

    public void sortIntArray() {

    int[] arrayToSort = new int[] { 48, 5, 89, 80, 81, 23, 45, 16, 2 };

    System.out.println("排序前");

    for (int i = 0; i 

    System.out.println(arrayToSort[i]);

    // 调用数组的静态排序方法sort

    Arrays.sort(arrayToSort);

    System.out.println("排序后");

    for (int i = 0; i 

    System.out.println(arrayToSort[i]);

    }

    public void sortStringArray() {

    String[] arrayToSort = new String[] { "Oscar", "Charlie", "Ryan",

    "Adam", "David" };

    System.out.println("排序前");

    for (int i = 0; i 

    System.out.println(arrayToSort[i]);

    System.out.println("排序后");

    // 调用数组的静态排序方法sort

    Arrays.sort(arrayToSort);

    for (int i = 0; i 

    System.out.println(arrayToSort[i]);

    }

    public void sortObjectArray() {

    Dog o1 = new Dog("dog1", 1);

    Dog o2 = new Dog("dog2", 4);

    Dog o3 = new Dog("dog3", 5);

    Dog o4 = new Dog("dog4", 2);

    Dog o5 = new Dog("dog5", 3);

    Dog[] dogs = new Dog[] { o1, o2, o3, o4, o5 };

    System.out.println("排序前");

    for (int i = 0; i 

    Dog dog = dogs[i];

    System.out.println(dog.getName());

    }

    Arrays.sort(dogs, new ByWeightComparator());

    System.out.println("排序后:");

    for (int i = 0; i 

    Dog dog = dogs[i];

    System.out.println(dog.getName());

    }

    }

    public static void main(String[] args) {

    ArraySortDemo t = new ArraySortDemo();

    t.sortIntArray();

    t.sortStringArray();

    t.sortObjectArray();

    }

    }

    package com.gjh.gee.arrays;

    public class Dog {

    private String name;

    private int weight;

    public Dog(String name, int weight) {

    this.setName(name);

    this.weight = weight;

    }

    public int getWeight() {

    return weight;

    }

    public void setWeight(int weight) {

    this.weight = weight;

    }

    public void setName(String name) {

    this.name = name;

    }

    public String getName() {

    return name;

    }

    }

    package com.gjh.gee.arrays;

    import java.util.Comparator;

    public class ByWeightComparator implements Comparator {

    public final int compare(Object pFirst, Object pSecond) {

    int aFirstWeight = ((Dog) pFirst).getWeight();

    int aSecondWeight = ((Dog) pSecond).getWeight();

    int diff = aFirstWeight - aSecondWeight;

    if (diff > 0)

    return 1;

    if (diff 

    return -1;

    else

    return 0;

    }

    }

    下面补充一个Collections.sort排序,原理和Arrays.sort差不多。

    //一个POJO例子

    class User {

    String name;

    String age;

    public User(String name,String age){

    this.name=name;

    this.age=age;

    }

    public String getAge() {

    return age;

    }

    public void setAge(String age) {

    this.age = age;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    }

    //具体的比较类,实现Comparator接口

    import java.util.Comparator;

    import java.util.List;

    import java.util.ArrayList;

    import java.util.Collections;

    public class ComparatorUser implements Comparator{

    public int compare(Object arg0, Object arg1) {

    User user0=(User)arg0;

    User user1=(User)arg1;

    //首先比较年龄,如果年龄相同,则比较名字

    int flag=user0.getAge().compareTo(user1.getAge());

    if(flag==0){

    return user0.getName().compareTo(user1.getName());

    }else{

    return flag;

    }

    }

    }

    //测试类

    public class SortTest {

    public static void main(String[] args){

    List userlist=new ArrayList();

    userlist.add(new User("dd","4"));

    userlist.add(new User("aa","1"));

    userlist.add(new User("ee","5"));

    userlist.add(new User("bb","2"));

    userlist.add(new User("ff","5"));

    userlist.add(new User("cc","3"));

    userlist.add(new User("gg","6"));

    ComparatorUser comparator=new ComparatorUser();

    Collections.sort(userlist, comparator);

    for (int i=0;i

    User user_temp=(User)userlist.get(i);

    System.out.println(user_temp.getAge()+","+user_temp.getName());

    }

    }

    }

    //首先年龄排序,如果年龄相同,则按名字排序

    结果:

    1, aa

    2, bb

    3, cc

    4, dd

    5, ee                    //注意:同样是5岁的人,则比较名字(ee,ff),然后排序

    5, ff

    6, gg

    展开全文
  • 主要给大家整理介绍了最简单易懂的java数组排序方法,文中通过示例代码介绍的非常详细,对大家学习或者使用java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • java冒泡排序 代码为排序源代码 简洁明了 无其他
  • Java数组排序方法详解

    千次阅读 2021-02-27 11:03:41
    数组,本身是有序的元素序列,本文我们就来看看Java数组排序的几个方法。一、冒泡排序举 个 栗 子:5 2 0 4 1 3 一个容量为七的数组排升序(降序同理,最大值变最小就ok)①从这组数中找那个冒泡的(最大的),把它踢到...

    数组,其实就是一个给定了大小给定了类型的容器,在这容器中有你设定的元素,你可以对这些元素进行各种升降排列,或者找出其中特殊的元素并进行一系列的运算。数组,本身是有序的元素序列,本文我们就来看看Java数组排序的几个方法。

    一、冒泡排序

    举 个 栗 子:5 2 0 4 1 3 一个容量为七的数组排升序(降序同理,最大值变最小就ok)

    ①从这组数中找那个冒泡的(最大的),把它踢到最后 2 0 4 1 3 5

    ②重复上述行为 2 0 1 3 4 5

    ③重复~~ 2 0 1 3 4 5

    ④~~0 1 2 3 4 5

    ⑤~~0 1 2 3 4 5 完成

    Java代码实例:

    dfd7e45036708fb67d699eaa3491c74a.png

    二、选择排序

    还是刚才那个栗子:5 2 0 4 1 3 升序

    ①找到数组中最小的 放到第一个位置 0 5 2 4 1 3

    ②数组中剩下的找到最小的放在第二个位置 0 1 5 2 4 3

    ③ ~~ 0 1 2 5 4 3

    ④~~ 0 1 2 3 5 4

    ⑤~~0 1 2 3 4 5 完成

    Java代码实例:

    74c997fe675a1eea48e9855848859193.png

    三、插入排序

    个人认为就是在摸扑克牌 桌上的牌堆就是你的数组 一张一张的摸到手上,你的数组排序也就完成了。 这次你的牌堆为 5 2 0 4 1 3

    ,依次向手中加牌

    ①摸一张5 5

    ②摸一张2 放5左边 2 5

    ③~~ 0 2 5

    ④~~ 0 2 4 5

    ⑤~~ 0 1 2 4 5

    ⑥~~ 0 1 2 3 4 5

    Java代码实例:

    e9cc7cc493959fc145dbc3812d19fce2.png

    四、希尔排序

    希尔排序其实就是一种间隔交换,这次用个长点的栗子来让大家了解我的意图 一个拥有十个元素的数组

    43 95 38 30 41 72 60 74 24 32

    ①首先

    我以5为间隔。第一个和第六个比较,第二个和第七个比较,第三个和第八个比较......升序不变,降序则置换位置。(比如第一个43和第六个72升序不变换位置,第二个95和第七个60降序置换位置)

    得到置换结果 43 60 38 24 32 72 95 74 30 41

    ②接着我们采用3为间隔,也就是说类似第一个和第五个比较,方法同上。

    4164b8c47e07ee97ae96f90530bd6c92.png

    得到置换结果 24 32 30 41 60 38 43 74 72 95

    ③接着我们采用2为间隔,得到置换结果 :

    24 32 30 38 43 41 60 74 72 95

    ④最后以1为间隔 结果很简单 24 30 32 38 41 43 60 72 74 95

    大家不难发现我取间隔的方式如同下方代码一般,重复 int

    k/2,间隔选取其实并非唯一确定的,针对不同的数组,你们可以根据自己的经验来采用不同方式的间隔,在这里就不啰嗦了。

    Java代码如下

    a4fe38fc41fc46d83e615202da3793e6.png

    现在方案写完了 随机一个拥有十个元素的数组然后打印出排序如下 :

    28e39154784fcd82d1fd27ae391b41dc.png

    希尔排序虽然针对大多数数组排序有较高的效率但是其稳定性却令人堪忧,建议大家写文件时用插入排序,既有效率又算法稳定。

    以上就是为大家介绍的4种Java数组排序方法,在我们处理数组中的数据时能够为我们快速地对数组数据进行排序。当然,在Java中还有其他的排序算法,感兴趣的小伙伴可以观看本站的Java基础教程,学习其他的Java数组排序算法。

    展开全文
  • java数组自定义排序

    2017-10-31 15:35:59
    java数组的自定义排序,种类繁多,简单实现,可自由操控。
  • java中在运用数组进行排序功能时,一般有四种方法:快速排序法、冒泡法、选择排序法、插入排序法(希尔排序(Shell Sort)是插入排序的一种),下面是一些示例,需要的朋友可以参考下
  • java数组排序函数

    千次阅读 2020-06-08 16:20:14
    排序算法,基本的高级语言都有一些提供。C语言有qsort()函数,C++有sort()函数,java语言有Arrays类(不是Array)。...Java API对Arrays类的说明是:此类包含用来操作数组(比如排序和搜索)的各种方法。

    1.对基本数据类型的数组的排序

    (1)Arrays类中的sort()使用的是“经过调优的快速排序法”;

    (2)比如int[],double[],char[]等基数据类型的数组,Arrays类之只是提供了默认的升序排列,没有提供相应的降序排列方法。

    (3)要对基础类型的数组进行降序排序,需要将这些数组转化为对应的封装类数组,如Integer[],Double[],Character[]等,对这些类数组进行排序。(其实还不如先进行升序排序,自己在转为降序)。

    用默认的升序对数组排序

    函数原型

    • static void sort(int[] a) 对指定的 int 型数组按数字升序进行排序。
    • static void sort(int[] a, int fromIndex, int toIndex) 对指定 int 型数组的指定范围按数字升序进行排序。

    代码实例

    import java.util.Arrays;
    public class ArraysSort_11 {
        public static void main(String args[])
        {
            int[] a={1,4,-1,5,0};
            Arrays.sort(a);
            //数组a[]的内容变为{-1,0,1,4,5}
            for(int i=0;i<a.length;i++)
                System.out.print(a[i]+"  ");
        }
    }
    

    2.对复合数据类型的数据的排序

    函数原型:
    (1)public static void sort(T[] a,Comparator c) 根据指定比较器产生的顺序对指定对象数组进行排序。

    (2)public static void sort(T[] a,int fromIndex,int toIndex,Comparator c) 根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。

    说明:这个两个排序算法是“经过调优的合并排序”算法。
    代码实例

    package com.shuzu;
    
    import java.util.Arrays;
    import java.util.Comparator;
    
    public class fuhepaixu {
    	Point[] arr;
    	fuhepaixu(){
    		arr =new Point[4];
    		for(int i=0;i<4;i++) {
    			arr[i]=new Point();
    		}
    	}
    	public static void main(String args[]) {
    		fuhepaixu f =new fuhepaixu();
    		f.arr[0].x=1;
    		f.arr[1].x=2;
    		f.arr[2].x=0;
    		f.arr[3].x=4;
    		f.arr[0].y=2;	
    		f.arr[1].y=3;
    		f.arr[2].y=1;
    		f.arr[3].y=0;
    		Arrays.sort(f.arr,new myComparator());
    		for(int j=0;j<4;j++) {
    			System.out.println("("+f.arr[j].x+","+f.arr[j].y+")");
    		}
    	}
    
    }
    
    class Point{
    	int x;
    	int y;
    }
    
    class myComparator implements Comparator{
    	public int compare(Object arg0,Object arg1) {
    		Point t1 =(Point)arg0;
    		Point t2 =(Point)arg1;
    		if(t1.x!=t2.x) {
    			return t1.x>t2.x?1:-1;
    		}
    		else {
    			return t1.y>t2.y?1:-1;
    		}
    	}
    }
    

    Comparator是一个专用的比较器,当这个对象不支持自比较或者自比较函数不能满足要求时,可写一个比较器来完成两个对象之间大小的比较。Comparator体现了一种策略模式(strategy design pattern),就是不改变对象自身,而用一个策略对象(strategy object)来改变它的行为。

    PS:关于?:公式
    a>b?A:B
    意思是如果a>b则这个式子的值为A;
    否则值为B

    展开全文
  • java 数组排序后返回索引

    千次阅读 2020-06-06 21:17:37
    * 排序后返回索引 * @param v * @param <T> * @return */ static <T> int[] sortToIndex(T[] v) { Map<T, Queue<Integer>> indexMap = new HashMap<>(); for (int i=0; i<v...
  • Java数组排序:Java sort()方法

    万次阅读 2019-07-05 23:03:19
    Java 中实现数组排序的方式很多,除了利用 Arrays 类的 sort() 方法外,还可以编写自定义方法来实现自己的排序算法。本文介绍如何使用 Arrays 类提供的 sort() 方法来对数组进行排序。 使用 java.util.Arrays 类...
  • 最简单易懂的java数组排序方法

    千次阅读 多人点赞 2020-08-09 21:56:59
    1.快速排序 首先是最简单的Array.sort,直接进行排序: ...点击运行即可输出已排序数组数字。 2.部分排序法 使用Array.sort还可进行选择想要排序的部分数字,如将下角标编号为1~4的数字进行排序
  • java数组排序示例分享

    2020-09-04 13:10:31
    主要介绍了java数组排序示例,需要的朋友可以参考下
  • java数组排序的几种方法

    万次阅读 多人点赞 2018-06-22 09:07:05
    因为看书看到了java数组排序,所以将常用的几种排序方法写下来,仅供参考。(1)用sort排序(从小到大)int[] arr = {5,2,66,3,7};Arrays.sort(arr);//Arrays是util包for(int i : arr){ System.out.println(i);}(2)...
  • Java数组排序算法.docx

    2021-01-29 19:28:53
    本文介绍了Java数组的三种排序。冒泡,直接选择和反转。配有图片解释及完整代码。
  • Java数组排序之冒泡排序算法

    千次阅读 2019-04-17 20:45:29
    其中冒泡排序是比较常用的数组排序算法之一,冒泡排序主要是排序数组的过程总是将小数往前放,大数往后放。冒泡排序其实就是对比相邻的值,如果满足条件就交换值。 冒泡排序示例: 首先创建一个数组,这数组里面的...
  • Java数组排序-选择排序

    千次阅读 2017-07-28 15:37:29
    Java数组排序-选择排序
  • java代码-JAVA数组排序

    2021-07-15 04:30:26
    java代码-JAVA数组排序
  • 我查阅网上资料未见到关于数组中有重复元素时如何得到排序后的数组索引(所有元素的索引),所有自己写了一个简单的版本,与大家一起分享.
  • Java数组排序-冒泡排序

    千次阅读 2017-07-28 15:18:27
    Java数组排序-冒泡排序
  • import java.util.Arrays; //冒泡排序 public class Testmaopao { public static void main(String[] args) { int [] array={1,3,6,8,22,12}; for(int i=0;i&lt;array.length-1;i++){ ...
  • 1、为节点排序。节点由3个字段组成,包括num ,weight ,height 。先按照weight升序排序,再按照height降序排序。 2、使用Comparator接口规则:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的...
  • JAVA数组排序

    2011-10-04 19:45:05
    JAVA数组排序经典之一,冒泡法,最基础也最容易理解的一种排序方法
  • JAVA中在运用数组进行排序功能时,一般有四种方法:快速排序法、冒泡法、选择排序法、插入排序法。  快速排序法主要是运用了Arrays中的一个方法Arrays.sort()实现。  冒泡法是运用遍历数组进行比较,通过不断...
  • 快速排序(Quicksort)是对冒泡排序的一种改进。 快速排序的基本思想是:通过一...具体做法是:假设要对某个数组进行排序,首先需要任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它小的数都放...
  • Java实现数组排序

    千次阅读 2020-12-01 10:31:45
    选择排序法即是先将第一个数据分别与右侧其他数据依次比较,当第一个数据较大时,对调两数据位置,最终第一个位置的数据将是数组元素的最小值;再对第二个数据分别与右侧其他数据依次比较,当第二个数据较大时,对调...
  • Java数组排序的实现

    千次阅读 2019-03-31 16:49:36
    文章目录自然升序排序自然降序排序数组倒置随机排序 自然升序排序 使用Arrays类:其中的sort()使用的是“经过调优的快速排序法” String[] data = {"1", "4", "3", "2"}; System.out.println(Arrays.toString...
  • java数组排序

    万次阅读 多人点赞 2019-05-15 21:00:57
    Java数组排序 开发工具与关键技术:myEclipse javaEE 作者:林国佳 撰写时间:20180515 选择排序: 就是第1与第2比,如果第1比第2大,位置互换, 互换后的第1与第3比,如果第1比第3大,位置互换, 一直到最后,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 363,531
精华内容 145,412
关键字:

java数组排序

java 订阅
友情链接: 线性判别器.zip