持有对象(集合)
来源:互联网 发布:韦德公牛数据 编辑:程序博客网 时间:2024/05/01 06:31
添加一组元素
在java.util包中的Arrays和Collections类中都有很多实用方法,可以在一个Collection中添加一组元素。Arrays.asList()方法接受一个数组或是一个用逗号分隔的元素列表(使用可变参数),并将其转换为一个List集合。Collections.addAll()方法接受一个Collection对象,以及一个数组或是一个用逗号分隔的列表,将元素添加到Collection中。
package com.huangfei.thinking.holding;import java.util.ArrayList;import java.util.Arrays;import java.util.Collection;import java.util.Collections;import java.util.List;public class AddingGroups { public static void main(String[] args) { /** * Collection的构造器可以接受另一个Collection,用它来将自身初始化,因此你可以使用Arrays.asList()来为这个构造器产生输入。 * 但是,Collection.addAll()方法运行起来要快得多,而且构建一个不包含元素的Collection,然后调用Collection.addAll() * 这种方式很方便,因此它是首选方式。 */ Collection<Integer> collection = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5)); Integer[] moreInts = {6, 7 ,8 , 9 , 10}; collection.addAll(Arrays.asList(moreInts)); /** * Collection.addAll()成员方法只能接受另一个Collection对象作为参数,因此它不如Arrays.asList() * 和Collections.addAll()灵活,这两个方法使用的都是可变参数列表。 */ Collections.addAll(collection, 11, 12, 13, 14, 15); Collections.addAll(collection, moreInts); /** * 你可以直接使用Arrays.asList()的输出,将其当作List,但是这种情况下,其底层表示的是数组,因此不能调整尺寸。如果你试图用add() * 或delete()方法在这种列表中添加或删除元素,就有可能会引发去改变数组尺寸的尝试,因此你将在运行时获得“UnsupportedOperationException” * (不支持的操作)的错误。 */ List<Integer> list = Arrays.asList(16, 17, 18,19, 20); list.set(1, 99); //list.add(21); }}
Arrays.asList()方法的限制是它对所产生的List的类型做出了最理想的假设,而并没有注意你对它会赋予什么样的类型。有时就会引发问题:
package com.huangfei.thinkinginjava.holding;import java.util.*;class Snow {}class Powder extends Snow {}class Light extends Powder {}class Heavy extends Powder {}class Crusty extends Snow {}class Slush extends Snow {}public class AsListInference { public static void main(String[] args) { List<Snow> snow1 = Arrays.asList(new Crusty(), new Slush(), new Powder()); /** * 当试图创建snow2时,Arrays.asList()中只有Power类型,因此它会创建List<Powder>而不是List<Snow>。 */ // List<Snow> snow2 = Arrays.asList(new Light(), new Heavy()); /** * Collections.addAll()工作的很好,因为它从第一个参数中了解到了目标类型是什么。 */ List<Snow> snow3 = new ArrayList<Snow>(); Collections.addAll(snow3, new Light(), new Heavy()); /** * 可以在Arrays.asList()中间插入一条“线索”,以告诉编译器对于由Arrays.asList()产生的List类型,实际的目标类型应该是什么,这 * 称为显示类型参数说明。 */ List<Snow> snow4 = Arrays.<Snow>asList(new Light(), new Heavy()); }}
List
package com.huangfei.thinkinginjava.holding;public class Pet { private String name; public Pet(String name){ this.name = name; } @Override public String toString() { return name; } @Override public boolean equals(Object obj) { return super.equals(obj); }}
package com.huangfei.thinkinginjava.holding;import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.List;public class ListFeatures { public static void main(String[] args) { List<Pet> pets = new ArrayList<Pet>(); pets.addAll(Arrays.asList(new Pet("Rat"), new Pet("Manx"), new Pet("Mutt"), new Pet("Pug"))); System.out.println("1:" + pets); Pet pet = new Pet("Hamster"); pets.add(pet); System.out.println("2:" + pets); /** * 当确定一个元素是否属于某个List,发现某个元素的索引,以及从某个List中移除一个元素时,都会用到equals()方法(它是根类Object的一部分)。 * 不同的类,equals()的定义可能有所不同。例如两个String只有在内容完全一样的情况下才会是等价的,因此必须意识到List的行为根据 * equals()的行为而有所变化。 */ System.out.println("3:" + pets.contains(pet)); int index = pets.indexOf(pet); System.out.println("4:" + pet + " " + index); pets.remove(pet); /** * subList()方法允许你很容易地从较大的列表中创建一个片段,而将其结果传递给这个较大的列表的containsAll()方法时,很自然的会得到 * true。我们从6中注意到顺序并不重要,在sub上调用Collections.shuffle()方法,不会影响containsAll()结果。subList() * 所产生的列表的幕后是初始化列表,因此,对所返回的列表的修改都会反映到初始列表中,反之亦然(7中显示的结果很好的证明了这一点)。 */ List<Pet> sub = pets.subList(1, 4); System.out.println("sublist:" + sub); System.out.println("5:" + pets.containsAll(sub)); Collections.shuffle(sub); System.out.println("shuffle sublist:" + sub); System.out.println("6:" + pets.containsAll(sub)); System.out.println("7:" + pets); /** * retainAll()方法是一种有效的“交集”操作,在本例中,它保留了所有同时在copy和sub中的元素。请再次注意,所产生的行为依赖于equals()方法 */ List<Pet> copy = new ArrayList<Pet>(pets); sub = Arrays.asList(pets.get(0), pets.get(2)); System.out.println("sub:" + sub); copy.retainAll(sub); System.out.println("copy:" + copy); /** * 通过toArray()方法,可以将任意的Collection转换为一个数组。这是一个重载方法,其无参数版本返回的是Object数组,但是如果你向这个重载版本 * 传递目标类型的数据,那么它将产生指定类型的数据(假设它能通过类型检查)。如果参数数组太小,存放不下List中的所有元素(就像本例),toArray()方法 * 将创建一个具有合适尺寸的数组。 */ Object[] o = pets.toArray(); Pet[] pa = pets.toArray(new Pet[0]); /** * 方法asList()和subList()返回不可变List,因为它们是由底层数组和列表“支持”。如果您的结构修改我们在已被接受的部分中所做的备份列表,您可以得到一个并发的修改例外。 * 因此,程序在子列表上运行支持的列表。或者,通过创建单独的副本来避免错误返回子列表并将其用作removeAll()的参数。 */ Pet[] petArray = new Pet[10]; for (int i = 0; i < petArray.length; i++) { petArray[i] = new Pet(i + ""); } //List<Pet> petList = Arrays.asList(petArray); List<Pet> petList = new ArrayList<Pet>(Arrays.asList(petArray)); System.out.println("petList:" + petList); List<Pet> subList = petList.subList(petList.size() / 4, petList.size() / 2); System.out.println("subList:" + subList); //如果支持列表在结构上修改,子列表的语义就会被取消。 //petList.removeAll(subList); subList.clear(); System.out.println("petList:" + petList); System.out.println("subList:" + subList); }}//output1:[Rat, Manx, Mutt, Pug]2:[Rat, Manx, Mutt, Pug, Hamster]3:true4:Hamster 4sublist:[Manx, Mutt, Pug]5:trueshuffle sublist:[Mutt, Manx, Pug]6:true7:[Rat, Mutt, Manx, Pug]sub:[Rat, Manx]copy:[Rat, Manx]petList:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]subList:[2, 3, 4]petList:[0, 1, 5, 6, 7, 8, 9]subList:[]
ListIterator
package com.huangfei.thinkinginjava.holding;import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.ListIterator;public class ListIteration { public static void main(String[] args) { List<Pet> pets = new ArrayList<Pet>(); pets.addAll(Arrays.asList(new Pet("Rat"), new Pet("Manx"), new Pet("Mutt"), new Pet("Pug"))); /** * ListIterator只能用于各种List类的访问,ListIterator可以双向移动,并且可以产生相对于迭代器在列表中指向的当前位置的前一个和 * 后一个元素的索引,并且可以使用set()替换它访问过的最后一个元素,而且还可以通过调用listIterator(n)方法创建一个一开始就指向列表 * 索引为n的元素处的ListIterator。 */ ListIterator<Pet> lt = pets.listIterator(); while(lt.hasNext()){ System.out.print(lt.next() + ", " + lt.nextIndex() + ", " + lt.previousIndex() + "; "); } System.out.println(); while(lt.hasPrevious()){ System.out.print(lt.previous() + " "); } System.out.println(); System.out.println(pets); lt = pets.listIterator(2); while(lt.hasNext()){ lt.next(); lt.set(new Pet("Hamster")); } System.out.println(pets); }}//outputRat, 1, 0; Manx, 2, 1; Mutt, 3, 2; Pug, 4, 3; Pug Mutt Manx Rat [Rat, Manx, Mutt, Pug][Rat, Manx, Hamster, Hamster]
LinkedList
package com.huangfei.thinkinginjava.holding;import java.util.Arrays;import java.util.LinkedList;public class LinkedListIteration { public static void main(String[] args) { LinkedList<Pet> pets = new LinkedList<Pet>(); pets.addAll(Arrays.asList(new Pet("Rat"), new Pet("Manx"), new Pet("Mutt"), new Pet("Pug"))); System.out.println(pets); /** * getFirst()和element()完全一样,他们都返回列表的头(第一个元素),而并不移除它,如果List为空,则抛出NoSuchElementException。 * peek()方法与这两个方法只是稍有差异,它在列表为空的时候返回null。 */ System.out.println("pets.getFirst():" + pets.getFirst()); System.out.println("pets.element():" + pets.element()); System.out.println("pets.peek():" + pets.peek()); /** * remove()与removeFirst())也完全是一样的,它们移除并返回列表的头,而在列表为空的时候抛出NoSuchElementException。 * poll()稍有差异,它在列表为空的时候返回null。 */ System.out.println("pets.remove():" + pets.remove()); System.out.println("pets.removeFirst():" + pets.removeFirst()); System.out.println("pets.poll():" + pets.poll()); /** * addFirst()将某个元素插入到列表的首端 * offer()、add()和addLast()相同,它们都将某个元素插入到列表的尾端 */ System.out.println(pets); pets.addFirst(new Pet("Hamster")); System.out.println("After addFirst():" + pets); pets.offer(new Pet("Cymric")); System.out.println("After offer():" + pets); pets.add(new Pet("Huangfei")); System.out.println("After add():" + pets); pets.addLast(new Pet("Xiaoli")); System.out.println("After addLast():" + pets); //removeLast()移除并返回列表的最后一个元素 System.out.println("pets.removeLast():" + pets.removeLast()); }}//output[Rat, Manx, Mutt, Pug]pets.getFirst():Ratpets.element():Ratpets.peek():Ratpets.remove():Ratpets.removeFirst():Manxpets.poll():Mutt[Pug]After addFirst():[Hamster, Pug]After offer():[Hamster, Pug, Cymric]After add():[Hamster, Pug, Cymric, Huangfei]After addLast():[Hamster, Pug, Cymric, Huangfei, Xiaoli]pets.removeLast():Xiaoli
创建一个空的LinkedList,通过使用ListIterator,将若干个Integer插入这个List,插入时,总是将它们插入到List的中间。
package com.huangfei.thinkinginjava.holding;import java.util.LinkedList;import java.util.ListIterator;public class MiddleInsertion { public static void main(String[] args) { LinkedList<Integer> list = new LinkedList<Integer>(); ListIterator<Integer> lt = list.listIterator(); for (int i = 1; i <= 10; i++) { lt.add(i); if(i % 2 == 0) lt.previous(); } System.out.println(list); }}//output[1, 3, 5, 7, 9, 10, 8, 6, 4, 2]
Stack
尽管已经有了java.util.Stack,但是由于Java设计者在创建时使用了继承的方式(继承List),使得java.util.Stack具有其他不需要的方法,所以通过LinkedList实现自定义Stack会是一种比较好的选择。
package com.huangfei.thinkinginjava.holding;import java.util.LinkedList;/** * 用LinkedList实现栈 * @author huangfei * * @param <T> */public class Stack<T> { private LinkedList<T> storage = new LinkedList<T>(); public void push(T t){ storage.addFirst(t); } public T peek(){ return storage.peek(); } public T pop(){ return storage.removeFirst(); } public boolean isEmpty(){ return storage.isEmpty(); } public String toString(){ return storage.toString(); }}
Queue
LinkedList提供了方法以支持队列的行为,并且它实现了Queue接口,因此LinkedList可以用作Queue的一种实现。
PriorityQueue是所谓的优先级队列,比如构建了一个消息系统,某些消息比其他消息更重要,因而应该更快地得到处理,那么它们何时得到处理就与它们何时到达无关。
当在PriorityQueue调用offer()方法来插入一个对象时,这个对象会在队列中被排序,默认的排序将使用对象在队列中的自然顺序,但是可以通过提供Comparator来修改这个顺序。
package com.huangfei.thinkinginjava.holding;import java.util.Arrays;import java.util.Collections;import java.util.List;import java.util.PriorityQueue;import java.util.Queue;import java.util.Random;public class PriorityQueueDemo { private static void printQueue(Queue queue){ while(queue.peek() != null) System.out.print(queue.remove() + " "); System.out.println(); } public static void main(String[] args) { PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>(); Random rand = new Random(47); for (int i = 0; i < 10; i++) { priorityQueue.offer(rand.nextInt(i + 10)); } /** * 在PriorityQueue中,重复是允许的,最小的值拥有最高的优先级(如果是String,空格也可以算作值,并且比字母的优先级高)。 */ printQueue(priorityQueue); List<Integer> ints = Arrays.asList(25, 22, 20, 18, 14, 9, 3, 1, 1, 2, 3, 9, 14, 18, 21, 23, 25); priorityQueue = new PriorityQueue<Integer>(ints); printQueue(priorityQueue); /** * 通过传入Collections.reverseOrder()使得PriorityQueue产生反序的效果 */ priorityQueue = new PriorityQueue<Integer>(ints.size(), Collections.reverseOrder()); priorityQueue.addAll(ints); printQueue(priorityQueue); PriorityQueue<Dummy> queue = new PriorityQueue<Dummy>(); System.out.println("Adding 1st instance..."); queue.offer(new Dummy()); System.out.println("Adding 2nd instance..."); /** * 会报java.lang.ClassCastException: com.huangfei.thinkinginjava.holding.Dummy * cannot be cast to java.lang.Comparable * Integer、String已经内建了自然排序,如果想在PriorityQueue中使用自己的类,就必须包含额外的功能以产生自然排序, * 或者必须提供自己的Comparator。 */ queue.offer(new Dummy()); }}class Dummy {}//output0 1 1 1 1 1 3 5 8 14 1 1 2 3 3 9 9 14 14 18 18 20 21 22 23 25 25 25 25 23 22 21 20 18 18 14 14 9 9 3 3 2 1 1 Adding 1st instance...Adding 2nd instance...Exception in thread "main" java.lang.ClassCastException: com.huangfei.thinkinginjava.holding.Dummy cannot be cast to java.lang.Comparable at java.util.PriorityQueue.siftUpComparable(PriorityQueue.java:633) at java.util.PriorityQueue.siftUp(PriorityQueue.java:629) at java.util.PriorityQueue.offer(PriorityQueue.java:329) at com.huangfei.thinkinginjava.holding.PriorityQueueDemo.main(PriorityQueueDemo.java:52)
- 持有对象(集合)
- 深入java--持有对象(集合基础)
- [Java基础] 持有对象(集合框架)-Set-TreeSet
- 持有对象(容器)
- 集合只是持有对象的引用
- Java容器(集合),持有对象总结
- Java容器(集合),持有对象总结
- 持有对象
- 持有对象
- 持有对象
- 持有对象
- 持有对象
- 持有对象
- 持有对象
- 持有对象
- <Java编程思想>持有对象(笔记)
- java容器(持有对象方式)小结
- 第十一章:持有对象(上)
- bzoj 2818(莫比乌斯)
- C语言(14)纸牌游戏1
- noi2017解题报告(部分)
- 使用ActiveMQ进行C++与C#的通信1
- 前端防止xss攻击的最直接方式,分享一下
- 持有对象(集合)
- handler传递多种复杂数据
- vue双向绑定原理
- 【caffe源代码的梳理之四】caffe数据I/O模块——数据读取层DataLayer
- [学习笔记]微信非80端口网页授权
- android 权限申请
- 第二个项目:多线程
- tensorflow加载saver.restore目录报错
- 计算器(1)