list排序

//集合与数组的区别：集合不定长度，数组定长；集合只存储对象，数组什么都可以存。 //集合框架内不同的集合依据其内部不同的数据结构进行区分 Iterable//(接口)(内部有返回迭代器的方法) |--Collection //(接口)单列集合。方法：添加；删除；判断；获取(迭代器)。Itertor定义在Collection内部(Itertor是个内部类) //迭代器与枚举的区别：(1)迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的 collection 移除元素;(2)方法名称得到了改进。 |--List //(接口)有序的（存取顺序一致）；元素可重复；元素有角标；有ListIterator列表迭代器。 //方法：添加；删除；判断；获取；修改；listItertor(获取列表迭代器，列表迭代器在Itertor上增加了新功能)。注意：使用迭代器容易出现并发修改异常 |--ArrayList //底层数据结构为数组；查询快。不同步，不安全；可变长度数组(以50%的速度增长:*3/2+1)；多了个枚举（过时了，不用） |--Vector //底层数据结构为数组；支持枚举；效率低被ArrayList取代；同步，安全；可变长度数组(以100%的速度增长) |--LinkedList //底层数据结构为链表；增删快。不同步，不安全 |--Set //(接口)无序的；元素不可重复

集合排序 使用List中的sort(Comparator c)方法实现。Comparator是比较器接口，从这里传入比较的方式。 实现接口Comparable 重写CompareTo方法，在这个方法内部定义比较的条件。 比如String类就是实现了这个接口。 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。而这个比较就是依赖于各种数据类型的CompareTo。 这种方式不依赖比较器，所以调用sort方法的时候可以不写参数。 依赖比价器Comparator 实现Comparator这个接口里面只有一个方法，是一个函数式接口只要实现compare一个方法就行了。所以你可以直接在类中实现也可以在sort方法中直接用lambda实现就好了。compare返回大于0是大于，等于0是相等，小于0是小于。 来源： https://www.cnblogs.com/macht/p/11722483.html

主要讲述对list进行排序的几种方式 1、先来个简单的，上代码 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class sort { 　　public static void main(String[] args) { 　　List<Integer> list = new ArrayList<Integer>(); 　　list.add(new Integer(5)); 　　list.add(new Integer(13)); 　　list.add(new Integer(4)); 　　list.add(new Integer(9)); 　　Collections.sort(list); 　　System.out.println(list.toString()); 　　} } 程序运行结果： [4, 5, 9, 13]，这种简单的排序直接按照自然顺序进行升序排列。 2、list参数类型相对复杂的排序 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class sort { 　　public static void main

1 List<Integer> list = Arrays.asList(3, 1, 2); 2 //已知集合元素的情况下就别用 list.add了吧。。。 3 list.sort(new Comparator<Integer>() { 4 @Override 5 public int compare(Integer i1,Integer i2){ 6 return i1.compareTo(i2);//正序排列 7 }; 8 }); 一，匿名内部类 1 list.sort((a,b)->a.compareTo(b)); 二，由于目标类型（Comparator接口）是函数式接口，所以可以传入Lamdba表达式作为排序条件 1 list.sort(Integer::compareTo); 三，由于Lamdba表达式只有一条语句，因此可以转换为类对象方法引用，将函数式接口的第一个参数作为方法的调用者，剩下的参数作为冒号后面方法的参数 此帖子不定期更新，现在比较粗糙 刚刚注册博客园 问下插入代码块后怎么撤销啊？一直占着位置，看到的回复下，谢谢 来源： https://www.cnblogs.com/yanyan-rourou/p/11718745.html

集合应用 A.Collections工具 1）Collections和Collection的区别？ Collection：集合：顶层次的一个根接口，有两个子接口：List,Set Collections：对集合操作的工具类，具体的类：它针对集合进行操作 2）功能 public static <T> void sort(List<T> list)：默认的自然排序，将集合中的元素升序排序 import java.util.ArrayList; import java.util.Collections; public class Demo01 { public static void main(String[] args) { // 创建一个集合对象 ArrayList<Integer> al = new ArrayList<Integer>(); // 添加元素 al.add(20); al.add(19); al.add(21); al.add(18); al.add(17); al.add(16); // 排序前 System.out.println(al);// [20, 19, 21, 18, 17, 16] // 自然排序后 Collections.sort(al); System.out.println(al);// [16, 17, 18, 19, 20, 21] } }

集合（Collections---sort） 1、在集合中我们知道List是无无法对元素进行排序的，所以在集合框架中就有了Collections这个类。 2、Collections中的方法都是静态的，没有构造方法 3、Collections中提供了srot的两个用于比较的方法，注意不能对Set集合进行排序。 4、总结: 一般只要涉及到了对象的排序都要涉及到两个接口：一个是Comparable,一个是Comarator 5、示例： /** Collections的两种排序方法： 1.根据元素的自然顺序对指定的列表进行排序 public static <T extends Comparable<? superT>> void sort(List<T> list) 说明：传进来的集合中元素的类型不确定，但是这个元素的类型一定是Comparable的 子类，使得元素自身就具备比较性，Comparable中传进来的元素的类型也不确定（Student） 2、根据指定的比较器进行排序 public static<T> voidsort(List<T> list,Comparator<? super T> c); */ import java.util.*; //自定义比较器，根据字符串的长度排序 class StrLenComparator implements Comparator

Java集合大致可分为：List,Set,Map,Queue List:有序，可重复 Set:无序（输出和插入顺序不一定一致），不可重复 Map:映射关系,根据key去访问value Queue:队列，先进先出(FIFO) 集合类只能存储对象 List< int > // 错误 List<Integer> Collection体系结构 圆圈表示:interface 长方形表示：class 带三角的实线代表继承关系，使用关键字extends 带三角的虚线代表实现关系，使用关键字implements Iterable iterable定义了iterator()，forEach(Consumer<? super T> action) 这2个方法用于 遍历元素 1.forEach方法遍历集合 Consumer是一个函数式接口，只有一个accept(T t)方法，可以使用Lambda表达式 public static void main(String[] args){ Collection <String> coll = new HashSet<> (); // 在集合中添加10个元素 for ( int i=0;i<10;i++ ){ coll.add( "小王"+ i); } // 使用forEach遍历集合 coll.forEach(name-> System.out.println

def merge_sort(arr): if len(arr) == 1: return arr p = 0 n = len(arr) q = (p+n)//2 return merge(arr, merge_sort(arr[p:q]), merge_sort(arr[q:])) def merge(arr, arr1, arr2): temp = list() i = j = 0 for r in range(len(arr)): if i < len(arr1) and j < len(arr2): # <= 保证稳定性 if arr1[i] <= arr2[j]: temp.append(arr1[i]) i += 1 else: temp.append(arr2[j]) j += 1 else: if i < len(arr1): temp.extend(arr1[i:]) else: temp.extend(arr2[j:]) return temp def quick_sort(arr): if len(arr) <= 1: return arr privot = arr[0] larr, rarr = partition(arr[1:], privot) return quick_sort(larr) + [privot] + quick_sort(rarr)

1、abs(n) 函数返回数字的绝对值 参数n可以是整数，浮点数，复数 print(abs(10)) #n为正数 输出10 print(abs(-10)) #n为负数 输出10 print(abs(-10.12)) #n为浮点数 输出10.12 2、all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。 元素除了是 0、空、None、False 外都算 True。 参数--》元组或列表 #列表、字符串为例 print("列表都不为空或0",all(['a','b','c','d'])) print("列表存在一个为空的元素",all(['a','b','','d'])) print("列表存在一个为0的元素 ",all([0,1,23,])) print("列表存在一个为True的元素 ",all(['2',1,23,True])) print("列表存在一个为False的元素",all(['2',1,23,False])) print("列表存在一个空格的元素",all(['a','b',' ','d'])) print("列表存在一个\\n的元素",all(['a','b','\n','d'])) print("列表存在一个\\t的元素",all(['a','b','\t','d']))

lambda使用案例： 需求1：对List集合中的User按照age的大小进行排序输出： 1.普通的写法： private static List<User> list= new ArrayList<User>(); public static void main (String[] args) { list.add( new User( 34 )); list.add( new User( 14 )); list.add( new User( 24 )); System. out .println( "排序前：" +list.toString()); //对list集合的数据进行按照年龄排序 Collections.sort(list, new Comparator<User>() { @Override public int compare (User o1, User o2) { // TODO Auto-generated method stub return Integer.compare(o1.age, o2.age); } }); System. out .println( "排序后：" +list.toString()); } ------------------------ 输出结果： 排序前：[ 34 , 14 , 24 ] 排序后：[ 14 , 24 , 34