精华内容
下载资源
问答
  • java文件夹按时间、大小等排序

    热门讨论 2011-04-08 01:02:45
    java文件夹排序,按时间、大小等排序。。。。。。
  • Java数组去重排序从大到小

    千次阅读 2018-07-31 11:22:04
    Java小白的独立写出的第一个Java程序,虽然是很简单的程序,氮素我也花了很长的时间,写出来还是很开心的   ​ package arraySort; import java.util.Scanner; /* * 数组去重排序 */ public class arrayaa {...

    Java小白的独立写出的第一个Java程序,虽然是很简单的程序,氮素我也花了很长的时间,写出来还是很开心的

     

    ​
    package arraySort;
    
    import java.util.Scanner;
    
    /*
     * 数组去重排序
     */
    public class arrayaa {
    	public static void main(String[] args) {
    		int demoArray[];// 定义数组
    		int i, j, temp;
    		demoArray = new int[5];// 分配内存空间
    		/*
    		 * 或者在定义的同时分配空间 int demoArray[] = new int[5];
    		 */
    		// long total = 0;
    		int len = demoArray.length;// len为数组长度
    		System.out.print("请输入" + len + "个整数,以空格为分隔:");
    		Scanner sc = new Scanner(System.in);
    		for (i = 0; i < len; i++) {
    			demoArray[i] = sc.nextInt();
    		}
    		for (int x : demoArray) {
    			System.out.print(x + " ");
    		}
    		System.out.println(" ");
    		/*
    		 * 以下数组去重
    		 */
    		for (i = 0; i < len - 1; i++) {
    			for (j = i + 1; j < len; j++) {
    				if (demoArray[i] == demoArray[j]) {
    					demoArray[j] = demoArray[len - 1];
    					len--;
    				}
    			}
    		}
    		System.out.print("去重后:");
    		for (i = 0; i < len; i++) {
    			System.out.print(demoArray[i] + " ");
    		}
    		System.out.println(" ");
    		/*
    		 * 以下数组排序
    		 */
    		for (i = 0; i < len; i++)
    			for (j = len - 2; j >= i; j--) // 从后向前,排好序的放在数组前面 
    				if (demoArray[j] < demoArray[j + 1]) {
    					temp = demoArray[j];
    					demoArray[j] = demoArray[j + 1];
    					demoArray[j + 1] = temp;
    				} // 冒泡排序
    		/*
    		 * 数组输出
    		 */
    		System.out.print("去重排序后的数组:");
    		for (i = 0; i < len; i++) {
    			System.out.print(demoArray[i] + " ");
    		}
    		sc.close();
    	}
    }
    
    ​

     

    展开全文
  • 快速排序:   快速排序由于排序效率在同为O(nlogn)的几种排序方法中效率较高,因此经常被采用,再加上快速...2.将比这个数)的数全放它的右边,小于或等于(大于或等于)它的数全放它的左边。 3.对左...

    快速排序:

      快速排序由于排序效率在同为O(nlogn)的几种排序方法中效率较高,因此经常被采用,再加上快速排序使用了分治法的思想,算是基础排序中比较高档的一种排序了。

    基本思想

    1.先从数列中取出一个数作为基准数,可以是第一个,也可是中间的或者最后的,但是第一步要把这个基准数与数组最后一位对换。
    2.将比这个数大(小)的数全放到它的右边,小于或等于(大于或等于)它的数全放到它的左边。
    3.对左右区间重复第二步,直到各区间只有一个数(递归定义)。

    详细图示

    在这里插入图片描述 

    图片来源于网络

    代码展示

    public class Quick {
    
        public static void main(String[] args) {
    
            Integer arrA[] = new Integer[] { 13, 1, 2, 43, 65, 23, 76, 77, 23, 11, 99 };
            Integer arrB[] = new Integer[] { 13, 1, 2, 43, 65, 23, 76, 77, 23, 11, 99 };
            Integer[] arr1 = quickSortBig2Small(arrA, 0, arrA.length - 1);
            System.out.println("从大到小:" + Arrays.toString(arr1));
            Integer[] arr2 = quickSortSmall2Big(arrB, 0, arrB.length - 1);
            System.out.println("从小到大:" + Arrays.toString(arr2));
    
        }
    
        /**
         * 快排从大到小
         */
        private static Integer[] quickSortBig2Small(Integer[] arr, int low, int high) {
    
            // 如果开始点和结束点没有重叠的时候,也就是指针没有执行到结尾
            if (low < high) {
    
                // 重新获取中间点
                int mid = getIndexFromBig2Small(arr, low, high);
                quickSortBig2Small(arr, low, mid - 1);
                quickSortBig2Small(arr, mid + 1, high);
            }
            return arr;
        }
    
        /**
         * 快排从小到大
         */
        private static Integer[] quickSortSmall2Big(Integer[] arr, int low, int high) {
    
            // 如果开始点和结束点没有重叠的时候,也就是指针没有执行到结尾
            if (low < high) {
    
                // 重新获取中间点
                int mid = getIndexFromSmall2Big(arr, low, high);
                quickSortSmall2Big(arr, low, mid - 1);
                quickSortSmall2Big(arr, mid + 1, high);
            }
            return arr;
        }
    
        /**
         * 交换数组元素
         */
        private static void swap(Integer[] arr, int low, int high) {
    
            int temp = arr[low];
            arr[low] = arr[high];
            arr[high] = temp;
        }
    
        /**
         * 获取中间值(从大到小)
         */
        private static int getIndexFromBig2Small(Integer[] arr, int low, int high) {
    
            // 中值作为中点
            int index = (low + high) / 2;
    
            int midNum = arr[index];
    
            // 无论取的值是哪一个,都应该将其放在最后面
            swap(arr, index, high);
    
            while (low < high) {
    
                // 左侧值大于或者等于右侧值时候,只需要移动指针即可,不需要交换( 注意 =,没有会陷入死循环)
                while (low < high && arr[low] >= midNum)
                    low++;
                swap(arr, low, high);
    
                // 右侧值小于或者等于右侧值时候,只需要移动指针即可,不需要交换
                while (low < high && arr[high] <= midNum)
                    high--;
                swap(arr, low, high);
            }
            return high;
        }
    
        /**
         * 获取中间值(从小到大)
         */
        private static int getIndexFromSmall2Big(Integer[] arr, int low, int high) {
    
            // 中值作为中点
            int index = (low + high) / 2;
    
            int midNum = arr[index];
    
            // 无论取的值是哪一个,都应该将其放在最后面
            swap(arr, index, high);
    
            while (low < high) {
    
                // 左侧值小于或者等于右侧值时候,只需要移动指针即可,不需要交换( 注意 =,没有会陷入死循环)
                while (low < high && arr[low] <= midNum)
                    low++;
                swap(arr, low, high);
    
                // 右侧值小大于于或者等于右侧值时候,只需要移动指针即可,不需要交换
                while (low < high && arr[high] >= midNum)
                    high--;
                swap(arr, low, high);
            }
            return high;
        }
    
    }
    
    

    运行图示

    在这里插入图片描述

    展开全文
  • Java - 按文件大小、名称、日期排序

    万次阅读 2019-03-23 10:38:04
    package chimomo.learning.java.code.file; import java.io.File; import java.util.Arrays; import java.util.Collections; import java.util.Date; import java.util.List; /** * @author Created by Chimomo ....
    package chimomo.learning.java.code.file;
    
    import java.io.File;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Date;
    import java.util.List;
    
    /**
     * @author Created by Chimomo
     */
    public class FileSorter {
        // Sort by file size.
        public static void sortBySize(String dir) {
            List<File> files = Arrays.asList(new File(dir).listFiles());
            Collections.sort(files, (File f1, File f2) -> {
                long diff = f1.length() - f2.length();
                if (diff > 0) {
                    return 1;
                } else if (diff == 0) {
                    return 0;
                } else {
                    return -1;
                }
            });
            for (File f : files) {
                if (f.isDirectory()) {
                    continue;
                }
                System.out.println(f.getName() + ":" + f.length());
            }
        }
    
        // Sort by name.
        public static void sortByName(String dir) {
            List<File> files = Arrays.asList(new File(dir).listFiles());
            Collections.sort(files, (File f1, File f2) -> {
                if (f1.isDirectory() && f2.isFile()) {
                    return -1;
                }
                if (f1.isFile() && f2.isDirectory()) {
                    return 1;
                }
                return f1.getName().compareTo(f2.getName());
            });
            for (File f : files) {
                System.out.println(f.getName());
            }
        }
    
        // Sort by date.
        public static void sortByDate(String dir) {
            File file = new File(dir);
            File[] fs = file.listFiles();
            Arrays.sort(fs, (File f1, File f2) -> {
                long diff = f1.lastModified() - f2.lastModified();
                if (diff > 0) {
                    return 1;
                } else if (diff == 0) {
                    return 0;
                } else {
                    return -1;
                }
            });
            for (int i = fs.length - 1; i >= 0; i--) {
                System.out.println(fs[i].getName() + ":" + new Date(fs[i].lastModified()));
            }
        }
    
        public static void main(String[] args) {
            System.out.println("Sort by size:");
            sortBySize("/Users/X");
            System.out.println();
    
            System.out.println("Sort by name:");
            sortByName("/Users/X");
            System.out.println();
    
            System.out.println("Sort by date:");
            sortByDate("/Users/X");
            System.out.println();
        }
    }
    

     

    展开全文
  • Test类 /* (程序头部注释开始) ... * 文件名称: 设计一个Java程序,设有一个给定的int类型数组并有一批数据,现让你用二种以上的方法对其进行升或降序排列。 * 作 者: 雷恒鑫 * 完成日期: 20

    Test类

    /* (程序头部注释开始)   
     * 程序的版权和版本声明部分   
     * Copyright (c) 2011, 烟台大学计算机学院学生    
     * All rights reserved.   
     * 文件名称: 设计一个Java程序,设有一个给定的int类型数组并有一批数据,现让你用二种以上的方法对其进行升或降序排列。
     * 作 者: 雷恒鑫    
     * 完成日期: 2012 年 11 月 16 日   
     * 版 本 号: V1.0    
     * 对任务及求解方法的描述部分   
     * 输入描述:设计一个Java程序,设有一个给定的int类型数组并有一批数据,现让你用二种以上的方法对其进行升或降序排列。
     * 问题描述:   
     * 程序输出:   
     * 程序头部的注释结束   
     */
    package Task_two;
    
    public class Test {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int[] a = {1,5,4,7,3,9,31,99,22,100};
    		Array array = new Array(a);
    		array.up_count();
    		array.down_count();
    	}
    
    }
    


    Array类

     

    package Task_two;
    
    //设计一个Java程序,设有一个给定的int类型数组并有一批数据,现让你用二种以上的方法对其进行升或降序排列。
    public class Array {
    	int[] a;
    
    	public Array(int[] b) {
    		int i = 0;
    		a = new int[b.length];
    		for (int c : b) {
    			a[i] = c;
    			i++;
    		}
    	}
    
    	public void up_count() {// 冒泡排序法,从大到小排列
    		int max;
    		for (int i = 0; i < a.length; ++i) {
    			for (int j = 0; j < a.length - i - 1; ++j) {
    				if (a[j] < a[j + 1]) {
    					max = a[j];
    					a[j] = a[j + 1];
    					a[j + 1] = max;
    				}
    			}
    		}
    		for (int i = 0; i < a.length; i++) {
    			System.out.print(a[i]+" ");	
    		}
    
    	}
    
    	public void down_count() {// 朴素排序法,从小到大排列
    		System.out.println();
    		int min;
    		for (int i = 0; i < a.length; i++) {
    			for (int j = i+1; j < a.length; ++j) {
    				if (a[i] > a[j]) {
    					min = a[i];
    					a[i] = a[j];
    					a[j] = min;
    				}
    			}
    		}
    		for (int i = 0; i < a.length; i++) {
    			System.out.print(a[i]+" ");	
    		}
    	}
    }


    运行结果:

    展开全文
  • java 时间排序

    千次阅读 2019-09-19 18:30:00
    排序使用的是 Collections.sort(List,Comparator) 自定义类实现Comparator接口 假如A的值大于B,你返回1。这样调用Collections.sort()方法就是升序 假如A的值大于B,你返回-1。这样调用Collections.sort()方法...
  • 牛逼!Java 入门精通,超全汇总版

    万次阅读 多人点赞 2021-05-06 19:40:33
    文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多...
  • 大排序算法 一、直接插入 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 二、希尔排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 三、简单选择 - 1.基本思路 - 2.代码实现 - 3.时间复杂度...
  • 新手小白学JAVA 学习路径 知识体系

    万次阅读 多人点赞 2021-03-31 20:21:03
    Java基础部分需要学习很多的内容,但是很多伙伴不清楚自己的学习路径 希望本文可以帮助你,本文是程序媛泡泡给大家总结的链接汇总,欢迎食用 因为泡泡平时比较忙,所以文章在逐步更新拓展中,可以关注后方便后续查看...
  • 大排序-java实现版

    2019-03-01 10:22:02
    大排序java实现版本,直接插入排序、折半插入排序、冒泡排序、简单选择排序、希尔插入排序、快速排序 、堆排序、2-路归并排序 、基数排序,并有时间比较,博文...
  • 顶堆代码、顶堆代码 实际应用及实例代码 顶堆删除图解代码、插入代码 顶堆插入图解 时间复杂度分析 1、百度-》概念:堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法,它是选择排序的一种...
  • Java 输入三个整数 从小到大排列

    千次阅读 多人点赞 2020-12-01 19:27:19
    今天突然一想控制台输入三个数,如何将这三个数从小到大排序 经过段短暂的思考,直接上代码: public class Test04 { public static void main(String[] args) { demo01(); } /*7.题目:输入三个整数x,y,z,请把...
  • Java 时间段比较、排序

    千次阅读 2012-09-08 10:40:09
    Java 时间段比较、排序   Java代码  import java.util.Date; import java.util.List; /** * Author: Moses Miao * Time: 11-12-23 上午12:08 * E-mail: mosesxin@gmail.com */ public ...
  • Java时间排序

    万次阅读 2018-09-12 13:11:37
    排序使用的是 Collections.sort(List,Comparator) 自定义类实现Comparator接口 假如A的值大于B,你返回1。这样调用Collections.sort()方法就是升序 假如A的值大于B,你返回-1。这样调用Collections.sort()方法...
  • java实现四种常用排序算法

    万次阅读 多人点赞 2019-03-29 11:20:28
    思想(从小到大排):每一趟将待排序序列中最大元素移到最后,剩下的为新的待排序序列,重复上述步骤直到排完所有元素。这只是冒泡排序的一种,当然也可以后往前排。 public void bubbleSort(int array[]) ...
  • Java时间数组的排序问题

    千次阅读 2019-03-27 17:16:57
    Java时间数组的排序问题 有一道习题: 准备一个长度是9的日期数组 使用1970年-2000年之间的随机日期初始化该数组 按照这些日期的时间进行升序排序 比如 1988-1-21 12:33:22 就会排在 1978-4-21 19:07:23 前面 ...
  • java的8种排序方法的空间复杂度和时间复杂度,进行了一个简单的统计
  • java8 List对象根据时间排序

    万次阅读 2019-05-14 21:00:52
    java8 List对象根据时间排序 直接上代码 rewardModelList 是我本地的 一个list ==List<实体> DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); SimpleDateFormat sdf = new SimpleDateFormat...
  • 排序是把一堆数组有小到大、由大到从头到尾按照一定的顺序排列起来的。 1、冒泡排序 冒泡排序指数组中的两个两个相比,数组中的一二相比、二三相比、三四相比········ 每两个数相比完就排一次。排完后,再...
  • java8之stream 多字段排序 时间排序

    千次阅读 2020-06-08 14:38:25
    Comparator.comparing 默认为降序排序, 升序代码:Comparator.comparing(stu::getA,Comparator.reverseOrder()) import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java...
  • 大排序算法Java

    万次阅读 多人点赞 2016-07-06 17:57:40
    概述 排序有内部排序和外部排序,内部排序是数据记录在内存中... 当n较,则应采用时间复杂度为O(nlog2n)的排序方法:快速排序、堆排序或归并排序序。  快速排序:是目前基于比较的内部排序中被认为是最好的方法,
  • //放在一起感觉又臭又长,所以每排序我单独放出来了,欢迎大家平均交流指出不足 import java.lang.reflect.Array; import java.util.*; public class EightKindOfSort { /*选择排序 (不稳定算法) * 基本思想:两...
  • java代码,测试排序所用时间。经常用到,所以分享分享
  • Java大排序算法的时间复杂度分析

    千次阅读 2019-03-13 13:49:04
    1.冒泡排序 2.快速排序 1)最佳情况下,每次选取的基数都能将区间数组刚好划分成相等的2段。第一次对长度为n的整个数组扫描一遍、比较n-1次、视为n;...······第二次开始,将数组二分,一直分...
  • 个人积累的Java工具类扩展类,包括字符数组转字符串,质数判断,辗转相除法求最大公约数,对字符串的一些判断,几种常见的数组排序、插入、查找等,闰年判断 日期字符串解析等与日期有关的操作,随机字符串。...
  • java8 对象集合按时间排序

    千次阅读 2020-05-06 16:04:48
    升序 coDoctorVOList.sort(Comparator.comparing(CoDoctorVO::getTime)); 降序 coDoctorVOList.sort((m1, m2) -> m2.getTime().compareTo(m1.getTime())); ps: getTime()是对象中获取时间参数的方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 395,315
精华内容 158,126
关键字:

java时间从大到小排序

java 订阅