精华内容
参与话题
问答
  • Collections

    2020-06-02 20:41:39
    CoLLections是集合工具类,用来对集合进行操作。 -pubLic static <T> booLean add ALL ()往集合中添加元素 -pubLic static void shuffLe(List<?> List)打乱顺序:打乱集合顺序 */ public class Demo...
    /*
    CoLLections是集合工具类,用来对集合进行操作。
     -pubLic static <T> booLean add ALL  ()往集合中添加元素
      -pubLic static void shuffLe(List<?> List)打乱顺序:打乱集合顺序
    */
    public class Demo02 {
        public static void main(String[] args) {
            ArrayList<String> list  =new ArrayList<>();
            // -pubLic static <T> booLean add ALL  ()往集合中添加元素
            Collections.addAll(list,"a","b","c","d","e");
            System.out.println(list);
            //pubLic static void shuffLe(List<?> List)打乱顺序:打乱集合顺序
            Collections.shuffle(list);
            System.out.println(list);
        }
    }
    
    展开全文
  • collections

    千次阅读 2016-07-06 01:36:33
    collections是Python内建的一个集合模块,提供了许多有用的集合类。OrderedDict是dict的子类,它记住了内容添加的顺序。使用dict时,Key是无序的。在对dict做迭代时,我们无法确定Key的顺序。如果要保持Key的顺序,...

    出自:廖雪峰的博客

    collections是Python内建的一个集合模块,提供了许多有用的集合类。

    OrderedDict是dict的子类,它记住了内容添加的顺序。


    使用dict时,Key是无序的。在对dict做迭代时,我们无法确定Key的顺序。

    如果要保持Key的顺序,可以用OrderedDict:

    >>> from collections import OrderedDict
    >>> d = dict([('a', 1), ('b', 2), ('c', 3)])
    >>> d # dict的Key是无序的
    {'a': 1, 'c': 3, 'b': 2}
    >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
    >>> od # OrderedDict的Key是有序的
    OrderedDict([('a', 1), ('b', 2), ('c', 3)])
    

    注意,OrderedDict的Key会按照插入的顺序排列,不是Key本身排序:

    >>> od = OrderedDict()
    >>> od['z'] = 1
    >>> od['y'] = 2
    >>> od['x'] = 3
    >>> od.keys() # 按照插入的Key的顺序返回
    ['z', 'y', 'x']
    

    OrderedDict可以实现一个FIFO(先进先出)的dict,当容量超出限制时,先删除最早添加的Key:

    from collections import OrderedDict
    
    class LastUpdatedOrderedDict(OrderedDict):
    
        def __init__(self, capacity):
            super(LastUpdatedOrderedDict, self).__init__()
            self._capacity = capacity
    
        def __setitem__(self, key, value):
            containsKey = 1 if key in self else 0
            if len(self) - containsKey >= self._capacity:
                last = self.popitem(last=False)
                print 'remove:', last
            if containsKey:
                del self[key]
                print 'set:', (key, value)
            else:
                print 'add:', (key, value)
            OrderedDict.__setitem__(self, key, value)
    
    展开全文
  • java中Collections.sort排序详解

    万次阅读 多人点赞 2015-03-06 15:21:31
    Comparator是个接口,可重写compare()及equals()这两个方法,用于比价功能;如果是null的话,就是使用元素的默认顺序,如a,b,c,d,e,f,g,就是a,b,c,d,e,f,g这样,当然数字也是这样的。 compare(a,b)方法:根据第一个...

     

    Comparator是个接口,可重写compare()及equals()这两个方法,用于比价功能;如果是null的话,就是使用元素的默认顺序,如a,b,c,d,e,f,g,就是a,b,c,d,e,f,g这样,当然数字也是这样的。

     

    compare(a,b)方法:根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
    equals(obj)方法:仅当指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时才返回 true。

     

    Collections.sort(list, new PriceComparator());的第二个参数返回一个int型的值,就相当于一个标志,告诉sort方法按什么顺序来对list进行排序。

    具体实现代码方法如下:

    Book实体类:

     

    package com.tjcyjd.comparator;
    
    import java.text.DecimalFormat;
    import java.text.SimpleDateFormat;
    import java.util.GregorianCalendar;
    import java.util.Iterator;
    import java.util.TreeMap;
    
    /**
     * 书实体类
     * 
     * @author yjd
     * 
     */
    public class Book implements Comparable { // 定义名为Book的类,默认继承自Object类
    	public int id;// 编号
    	public String name;// 名称
    	public double price; // 价格
    	private String author;// 作者
    	public GregorianCalendar calendar;// 出版日期
    
    	public Book() {
    		this(0, "X", 0.0, new GregorianCalendar(), "");
    	}
    
    	public Book(int id, String name, double price, GregorianCalendar calender,
    			String author) {
    		this.id = id;
    		this.name = name;
    		this.price = price;
    		this.calendar = calender;
    		this.author = author;
    	}
    
    	// 重写继承自父类Object的方法,满足Book类信息描述的要求
    	public String toString() {
    		String showStr = id + "\t" + name; // 定义显示类信息的字符串
    		DecimalFormat formatPrice = new DecimalFormat("0.00");// 格式化价格到小数点后两位
    		showStr += "\t" + formatPrice.format(price);// 格式化价格
    		showStr += "\t" + author;
    		SimpleDateFormat formatDate = new SimpleDateFormat("yyyy年MM月dd日");
    		showStr += "\t" + formatDate.format(calendar.getTime()); // 格式化时间
    		return showStr; // 返回类信息字符串
    	}
    
    	public int compareTo(Object obj) {// Comparable接口中的方法
    		Book b = (Book) obj;
    		return this.id - b.id; // 按书的id比较大小,用于默认排序
    	}
    
    	public static void main(String[] args) {
    		Book b1 = new Book(10000, "红楼梦", 150.86, new GregorianCalendar(2009,
    				01, 25), "曹雪芹、高鄂");
    		Book b2 = new Book(10001, "三国演义", 99.68, new GregorianCalendar(2008, 7,
    				8), "罗贯中 ");
    		Book b3 = new Book(10002, "水浒传", 100.8, new GregorianCalendar(2009, 6,
    				28), "施耐庵 ");
    		Book b4 = new Book(10003, "西游记", 120.8, new GregorianCalendar(2011, 6,
    				8), "吴承恩");
    		Book b5 = new Book(10004, "天龙八部", 10.4, new GregorianCalendar(2011, 9,
    				23), "搜狐");
    		TreeMap tm = new TreeMap();
    		tm.put(b1, new Integer(255));
    		tm.put(b2, new Integer(122));
    		tm.put(b3, new Integer(688));
    		tm.put(b4, new Integer(453));
    		tm.put(b5, new Integer(40));
    		Iterator it = tm.keySet().iterator();
    		Object key = null, value = null;
    		Book bb = null;
    		while (it.hasNext()) {
    			key = it.next();
    			bb = (Book) key;
    			value = tm.get(key);
    			System.out.println(bb.toString() + "\t库存:" + tm.get(key));
    		}
    	}
    }
    


    自定义比较器和测试类:

     

     

    package com.tjcyjd.comparator;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.GregorianCalendar;
    import java.util.Iterator;
    import java.util.List;
    
    public class UseComparator {
    	public static void main(String args[]) {
    		List<Book> list = new ArrayList<Book>(); // 数组序列
    		Book b1 = new Book(10000, "红楼梦", 150.86, new GregorianCalendar(2009,
    				01, 25), "曹雪芹、高鄂");
    		Book b2 = new Book(10001, "三国演义", 99.68, new GregorianCalendar(2008, 7,
    				8), "罗贯中 ");
    		Book b3 = new Book(10002, "水浒传", 100.8, new GregorianCalendar(2009, 6,
    				28), "施耐庵 ");
    		Book b4 = new Book(10003, "西游记", 120.8, new GregorianCalendar(2011, 6,
    				8), "吴承恩");
    		Book b5 = new Book(10004, "天龙八部", 10.4, new GregorianCalendar(2011, 9,
    				23), "搜狐");
    		list.add(b1);
    		list.add(b2);
    		list.add(b3);
    		list.add(b4);
    		list.add(b5);
    		// Collections.sort(list); //没有默认比较器,不能排序
    		System.out.println("数组序列中的元素:");
    		myprint(list);
    		Collections.sort(list, new PriceComparator()); // 根据价格排序
    		System.out.println("按书的价格排序:");
    		myprint(list);
    		Collections.sort(list, new CalendarComparator()); // 根据时间排序
    		System.out.println("按书的出版时间排序:");
    		myprint(list);
    	}
    
    	// 自定义方法:分行打印输出list中的元素
    	public static void myprint(List<Book> list) {
    		Iterator it = list.iterator(); // 得到迭代器,用于遍历list中的所有元素
    		while (it.hasNext()) {// 如果迭代器中有元素,则返回true
    			System.out.println("\t" + it.next());// 显示该元素
    		}
    	}
    
    	// 自定义比较器:按书的价格排序
    	static class PriceComparator implements Comparator {
    		public int compare(Object object1, Object object2) {// 实现接口中的方法
    			Book p1 = (Book) object1; // 强制转换
    			Book p2 = (Book) object2;
    			return new Double(p1.price).compareTo(new Double(p2.price));
    		}
    	}
    
    	// 自定义比较器:按书出版时间来排序
    	static class CalendarComparator implements Comparator {
    		public int compare(Object object1, Object object2) {// 实现接口中的方法
    			Book p1 = (Book) object1; // 强制转换
    			Book p2 = (Book) object2;
    			return p2.calendar.compareTo(p1.calendar);
    		}
    	}
    }
    

     

     

    展开全文
  • Python-collections模块

    万次阅读 多人点赞 2020-09-27 10:29:34
    collections模块 这个模块实现了特定目标的容器,以提供Python标准内建容器 dict、list、set、tuple 的替代选择。 Counter:字典的子类,提供了可哈希对象的计数功能 defaultdict:字典的子类,提供了一个工厂函数...

    collections模块

    这个模块实现了特定目标的容器,以提供Python标准内建容器 dict、list、set、tuple 的替代选择。

    • Counter:字典的子类,提供了可哈希对象的计数功能
    • defaultdict:字典的子类,提供了一个工厂函数,为字典查询提供了默认值
    • OrderedDict:字典的子类,保留了他们被添加的顺序
    • namedtuple:创建命名元组子类的工厂函数
    • deque:类似列表容器,实现了在两端快速添加(append)和弹出(pop)
    • ChainMap:类似字典的容器类,将多个映射集合到一个视图里面

    Counter

    Counter是一个dict子类,主要是用来对你访问的对象的频率进行计数。

    >>> import collections
    >>> # 统计字符出现的次数
    ... collections.Counter('hello world')
    Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
    >>> # 统计单词个数
    ... collections.Counter('hello world hello lucy'.split())
    Counter({'hello': 2, 'world': 1, 'lucy': 1})
    

    常用方法:

    • elements():返回一个迭代器,每个元素重复计算的个数,如果一个元素的计数小于1,就会被忽略

    • most_common([n]):返回一个列表,提供n个访问频率最高的元素和计数

    • subtract([iterable-or-mapping]):从迭代对象中减去元素,输入输出可以是0或者负数

    • update([iterable-or-mapping]):从迭代对象计数元素或者从另一个 映射对象 (或计数器) 添加

    >>> c = collections.Counter('hello world hello lucy'.split())
    >>> c
    Counter({'hello': 2, 'world': 1, 'lucy': 1})
    >>> # 获取指定对象的访问次数,也可以使用get方法
    ... c['hello']
    2
    >>> # 查看元素
    ... list(c.elements())
    ['hello', 'hello', 'world', 'lucy']
    >>> c1 = collections.Counter('hello world'.split())
    >>> c2 = collections.Counter('hello lucy'.split())
    >>> c1
    Counter({'hello': 1, 'world': 1})
    >>> c2
    Counter({'hello': 1, 'lucy': 1})
    >>> # 追加对象,+或者c1.update(c2)
    ... c1+c2
    Counter({'hello': 2, 'world': 1, 'lucy': 1})
    >>> # 减少对象,-或者c1.subtract(c2)
    ... c1-c2
    Counter({'world': 1})
    >>> # 清除
    ... c.clear()
    >>> c
    Counter()
    

    defaultdict

    返回一个新的类似字典的对象。 defaultdict 是内置 dict 类的子类。

    class collections.defaultdict([default_factory[, ...]])

    >>> d = collections.defaultdict()
    >>> d
    defaultdict(None, {})
    >>> e = collections.defaultdict(str)
    >>> e
    defaultdict(<class 'str'>, {})
    

    例子

    defaultdict的一个典型用法是使用其中一种内置类型(如str、int、list或dict等)作为默认工厂,这些内置类型在没有参数调用时返回空类型。

    >>> e = collections.defaultdict(str)
    >>> e
    defaultdict(<class 'str'>, {})
    >>> e['hello']
    ''
    >>> e
    defaultdict(<class 'str'>, {'hello': ''})
    >>> # 普通字典调用不存在的键时,报错
    ... e1 = {}
    >>> e1['hello']
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 'hello'
    

    使用 int 作为 default_factory

    >>> fruit = collections.defaultdict(int)
    >>> fruit['apple'] = 2
    >>> fruit
    defaultdict(<class 'int'>, {'apple': 2})
    >>> fruit['banana']  # 没有对象时,返回0
    0
    >>> fruit
    defaultdict(<class 'int'>, {'apple': 2, 'banana': 0})
    

    使用 list 作为 default_factory

    >>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
    >>> d = collections.defaultdict(list)
    >>> for k,v in s:
    ...     d[k].append(v)
    ...
    >>> d
    defaultdict(<class 'list'>, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})
    >>> d.items()
    dict_items([('yellow', [1, 3]), ('blue', [2, 4]), ('red', [1])])
    >>> sorted(d.items())
    [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
    

    使用 dict 作为 default_factory

    >>> nums = collections.defaultdict(dict)
    >>> nums[1] = {'one':1}
    >>> nums
    defaultdict(<class 'dict'>, {1: {'one': 1}})
    >>> nums[2]
    {}
    >>> nums
    defaultdict(<class 'dict'>, {1: {'one': 1}, 2: {}})
    

    使用 set 作为 default_factory

    >>> types = collections.defaultdict(set)
    >>> types['手机'].add('华为')
    >>> types['手机'].add('小米')
    >>> types['显示器'].add('AOC')
    >>> types
    defaultdict(<class 'set'>, {'手机': {'华为', '小米'}, '显示器': {'AOC'}})
    

    OrderedDict

    Python字典中的键的顺序是任意的,它们不受添加的顺序的控制。

    collections.OrderedDict 类提供了保留他们添加顺序的字典对象

    >>> o = collections.OrderedDict()
    >>> o['k1'] = 'v1'
    >>> o['k3'] = 'v3'
    >>> o['k2'] = 'v2'
    >>> o
    OrderedDict([('k1', 'v1'), ('k3', 'v3'), ('k2', 'v2')])
    

    如果在已经存在的 key 上添加新的值,将会保留原来的 key 的位置,然后覆盖 value 值。

    >>> o['k1'] = 666
    >>> o
    OrderedDict([('k1', 666), ('k3', 'v3'), ('k2', 'v2')])
    >>> dict(o)
    {'k1': 666, 'k3': 'v3', 'k2': 'v2'}
    

    namedtuple

    三种定义命名元组的方法:第一个参数是命名元组的构造器(如下的:Person1,Person2,Person3)

    >>> P1 = collections.namedtuple('Person1',['name','age','height'])
    >>> P2 = collections.namedtuple('Person2','name,age,height')
    >>> P3 = collections.namedtuple('Person3','name age height')
    

    实例化命名元组

    >>> lucy = P1('lucy',23,180)
    >>> lucy
    Person1(name='lucy', age=23, height=180)
    >>> jack = P2('jack',20,190)
    >>> jack
    Person2(name='jack', age=20, height=190)
    >>> lucy.name  # 直接通过 实例名.属性 来调用
    'lucy'
    >>> lucy.age
    23
    

    deque

    collections.deque 返回一个新的双向队列对象,从左到右初始化(用方法 append()),从 iterable(迭代对象)数据创建。如果 iterable 没有指定,新队列为空。
    collections.deque 队列支持线程安全,对于从两端添加(append)或者弹出(pop),复杂度O(1)。
    虽然 list 对象也支持类似操作,但是这里优化了定长操作(pop(0)、insert(0,v))的开销。
    如果 maxlen 没有指定或者是 None ,deque 可以增长到任意长度。否则,deque 就限定到指定最大长度。一旦限定长度的 deque 满了,当新项加入时,同样数量的项就从另一端弹出。

    支持的方法:

    • append(x):添加x到右端
    • appendleft(x):添加x到左端
    • clear():清除所有元素,长度变为0
    • copy():创建一份浅拷贝
    • count(x):计算队列中个数等于x的元素
    • extend(iterable):在队列右侧添加iterable中的元素
    • extendleft(iterable):在队列左侧添加iterable中的元素,注:在左侧添加时,iterable参数的顺序将会反过来添加
    • index(x[,start[,stop]]):返回第 x 个元素(从 start 开始计算,在 stop 之前)。返回第一个匹配,如果没找到的话,升起 ValueError 。
    • insert(i,x):在位置 i 插入 x 。注:如果插入会导致一个限长deque超出长度 maxlen 的话,就升起一个 IndexError 。
    • pop():移除最右侧的元素
    • popleft():移除最左侧的元素
    • remove(value):移去找到的第一个 value。没有抛出ValueError
    • reverse():将deque逆序排列。返回 None 。
    • maxlen:队列的最大长度,没有限定则为None。
    >>> d = collections.deque(maxlen=10)
    >>> d
    deque([], maxlen=10)
    >>> d.extend('python')
    >>> [i.upper() for i in d]
    ['P', 'Y', 'T', 'H', 'O', 'N']
    >>> d.append('e')
    >>> d.appendleft('f')
    >>> d.appendleft('g')
    >>> d.appendleft('h')
    >>> d
    deque(['h', 'g', 'f', 'p', 'y', 't', 'h', 'o', 'n', 'e'], maxlen=10)
    >>> d.appendleft('i')
    >>> d
    deque(['i', 'h', 'g', 'f', 'p', 'y', 't', 'h', 'o', 'n'], maxlen=10)
    >>> d.append('m')
    >>> d
    deque(['h', 'g', 'f', 'p', 'y', 't', 'h', 'o', 'n', 'm'], maxlen=10)
    

    ChainMap

    问题背景是我们有多个字典或者映射,想把它们合并成为一个单独的映射,有人说可以用update进行合并,这样做的问题就是新建了一个数据结构以致于当我们对原来的字典进行更改的时候不会同步。如果想建立一个同步的查询方法,可以使用 ChainMap

    可以用来合并两个或者更多个字典,当查询的时候,从前往后依次查询。简单使用:

    >>> d1 = {'apple':1,'banana':2}
    >>> d2 = {'orange':2,'apple':3,'pike':1}
    >>> combined1 = collections.ChainMap(d1,d2)
    >>> combined2 = collections.ChainMap(d2,d1)
    >>> combined1
    ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
    >>> combined2
    ChainMap({'orange': 2, 'apple': 3, 'pike': 1}, {'apple': 1, 'banana': 2})
    >>> for k,v in combined1.items():
    ...     print(k,v)
    ...
    orange 2
    apple 1
    pike 1
    banana 2
    >>> for k,v in combined2.items():
    ...     print(k,v)
    ...
    apple 3
    banana 2
    orange 2
    pike 1
    

    有一个注意点就是当对ChainMap进行修改的时候总是只会对第一个字典进行修改,如果第一个字典不存在该键,会添加。

    >>> d1 = {'apple':1,'banana':2}
    >>> d2 = {'orange':2,'apple':3,'pike':1}
    >>> c = collections.ChainMap(d1,d2)
    >>> c
    ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
    >>> c['apple']
    1
    >>> c['apple'] = 2
    >>> c
    ChainMap({'apple': 2, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
    >>> c['pike']
    1
    >>> c['pike'] = 3
    >>> c
    ChainMap({'apple': 2, 'banana': 2, 'pike': 3}, {'orange': 2, 'apple': 3, 'pike': 1})
    

    从原理上面讲,ChainMap 实际上是把放入的字典存储在一个队列中,当进行字典的增加删除等操作只会在第一个字典上进行,当进行查找的时候会依次查找,new_child() 方法实质上是在列表的第一个元素前放入一个字典,默认是{},而 parents 是去掉了列表开头的元素

    >>> a = collections.ChainMap()
    >>> a['x'] = 1
    >>> a
    ChainMap({'x': 1})
    >>> b = a.new_child()
    >>> b
    ChainMap({}, {'x': 1})
    >>> b['x'] = 2
    >>> b
    ChainMap({'x': 2}, {'x': 1})
    >>> b['y'] = 3
    >>> b
    ChainMap({'x': 2, 'y': 3}, {'x': 1})
    >>> a
    ChainMap({'x': 1})
    >>> c = a.new_child()
    >>> c
    ChainMap({}, {'x': 1})
    >>> c['x'] = 1
    >>> c['y'] = 1
    >>> c
    ChainMap({'x': 1, 'y': 1}, {'x': 1})
    >>> d = c.parents
    >>> d
    ChainMap({'x': 1})
    >>> d is a
    False
    >>> d == a
    True
    
    >>> a = {'x':1,'z':3}
    >>> b = {'y':2,'z':4}
    >>> c = collections.ChainMap(a,b)
    >>> c
    ChainMap({'x': 1, 'z': 3}, {'y': 2, 'z': 4})
    >>> c.maps
    [{'x': 1, 'z': 3}, {'y': 2, 'z': 4}]
    >>> c.parents
    ChainMap({'y': 2, 'z': 4})
    >>> c.parents.maps
    [{'y': 2, 'z': 4}]
    >>> c.parents.parents
    ChainMap({})
    >>> c.parents.parents.parents
    ChainMap({})
    
    展开全文
  • Collections

    千次阅读 2020-07-04 10:58:36
    Collections /* Collections提供了操作集合的常用算法,这些算法都是以静态方法的形式提供的。这些方法的第一个参数都是需要 操作的集合的引用。Collections提供的多数算符都是针对List类型的,也有部分可以操作...
  • commons-collections

    2018-04-23 13:49:41
    collections jar 包集合,使用Maven的可以直接使用!collections
  • Java中Collections.sort()排序详解

    万次阅读 多人点赞 2016-08-17 09:49:54
    java中Collections.sort排序详解java基础—— Collections.sort的两种用法,简单明了 。java List 排序 Collections.sort()Java 中 Comparable 和 Comparator 比较第一种:ComparableComparable 是排序接口。若一个...
  • Collections用法

    2018-07-11 09:47:28
    System.out.println(Collections.addAll(arr,123));//添加 System.out.println(Collections.binarySearch(arr, 4));//通过元素获取下标 Collections.copy(arr2,arr);//复制 System.out.println(Collections.disjoint...
  • MongoDB Collections

    2019-09-03 23:21:11
    如果集合不存在则创建集合,如果集合存在则在集合里面添加 db.myNewCollection2.insertOne( { x: 1 } ) 参考: https://docs.mongodb.com/manual/core/databases-and-collections/#collections ...
  • Guava collections -- Immutable Collections

    千次阅读 2016-07-09 11:17:52
    这次主要介绍是的是com.google.common.collect.Immutable Collections.一个集合的内容永远不会改变,下面详细的提供了一些额外的担保。
  • ImmutableCollections即不可变即,最初出现在Google 的Guava 中,在jdk的Java9中被引入。 JDK9,10中的ImmutableCollections只是一个存放不可变集合的一个容器,不是一个公共的API。 先看ImmutableCollections的...
  • Python collections.Counter()用法

    万次阅读 多人点赞 2018-10-22 14:24:18
    Python collections.Counter用法什么是collectionsCounterCounter操作例子 什么是collections collections在python官方文档中的解释是High-performance container datatypes,直接的中文翻译解释高性能容量数据类型...
  • python collections

    2018-04-19 10:55:50
    1.collections中namedtuple()的理解Python中存储系列数据,比较常见的数据类型有list,除此之外,还有tuple数据类型。相比与list,tuple中的元素不可修改,在映射中可以当键使用。tuple元组的item只能通过index访问...
  • Collections4

    千次阅读 2019-04-10 14:45:06
    一、maven依赖: <dependency> <groupId>org.apache.commons</groupId> ...commons-collections4</artifactId> <version>4.1</version> </dependency...
  • java 开发,应该很多人在使用 CollectionUtils时,都遇到【collectionscollections4】犹豫,到底该使用那个呢? 以下 简称C3,C4; 先看看 出处:(pacakges) C3:package org.apache.commons.collections C4:...
  • 集合工具类Collections深度解析

    万次阅读 2020-12-03 21:30:18
    本文主要介绍Collections的常用方法,例如 Collections.sort()、Collections.shuffle()、Collections.reverse()、Collections.addAll()、Collections.copy()、Collections.binarySearch()、Collections....
  • collections导入错误

    2019-12-21 17:20:36
    从Python3中导入collections from collections import Iterable from collections import Iterator 出现以下错误 DeprecationWarning: Using or importing the ABCs from ‘collections’ instead of from ...
  • Collection和Collections区别

    万次阅读 2019-08-28 14:18:09
    1.Collection: 是集合类的上层接口。本身是一个Interface,里面包含了一些集合的... Collections是一个集合框架的帮助类,里面包含一些对集合的排序,搜索以及序列化的操作。 最根本的是Collections是一个类, ...
  • Collections 工具类常见方法

    千次阅读 多人点赞 2019-10-09 21:31:59
    Collections 工具类常用方法: 排序 查找,替换操作 同步控制(不推荐,需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合) 排序操作 void reverse(List list)//反转 void shuffle(List list)//随机排序 ...
  • python Collections

    2016-12-31 16:37:22
    除了常见的list,dict,set,tuple容器外,python collections包提供了可选择的container,主要包括: Counter、deque、defaultdict、namedtuple、OrderedDict。 Counter 一个简单快速计数器 ...
  • collections 模块

    2018-06-06 11:05:11
    1. dequefrom collections import dequed = deque() print(d)# output: deque([]) 生成一个双端队列d.append(1) print(d)# output: deque([1])d.extendleft([2]) #在左边增加元素 d.popleft() 删除左边的元素。 ...
  • Collections工具类

    2020-04-14 17:09:44
    package sxt.gaoqi.container;...import java.util.Collections; import java.util.List; /* * Collections辅助类的使用 * Collection是接口,Collections是工具类 */ public class TestCollectio...
  • python itertools与collections

    千次阅读 2021-01-04 11:24:01
    collections 找出列表中出现次数最多的元素 namedtuple:命令元组,它是一个类工厂,接受类型的名称和属性列表来创建一个类。 deque:双端队列,是列表的替代实现。Python中的列表底层是基于数组来实现的,而deque...
  • Java Collections

    2017-03-28 17:27:07
    Java CollectionsJava Collection是Java的一个重要的部分,几乎所有的开发都会用到rt.jar包下面的集合类。 下面先看一下Java Collection的UML图(只画了其中的一常用的非Concurrent集合类)
  • Collections Collections.synchronizedCollection 集合的同步控制 Collections类中提供了多个synchronizedXxx方法: 该方法返回指定集合对象对应的同步对象,解决多线程并发访问集合时线程的安全问题最常用的集合类...
  • Collections.sort

    千次阅读 2019-03-02 13:58:10
    Collections.sort(list);//排序 总结: 1.对于String或Integer这些已经实现Comparable接口的类来说,可以直接使用Collections.sort方法传入list参数来实现默认方式(正序)排序; 2.如果不想使用默认方式(正序)...
  • Collections sort

    2015-05-14 23:07:27
    Collections.sort(logs, new Comparator() { @Override public int compare(ResLog o1, ResLog o2) { return o1.getCreateTime().after(o2.getCreateTime())?-1:1; } }); 当我们用...
  • Collection 和 Collections

    2017-03-18 15:36:37
    Collection 和 Collections 有什么区别 关系, 主要用哪个?

空空如也

1 2 3 4 5 ... 20
收藏数 160,384
精华内容 64,153
关键字:

collections