java collection(一)

1.Collection层次结构:

2.集合Conllection的基本概念：

(1)集合的基本认识：如StringBuffer&StringBuilder是集合（存储的对象类型是String）。数组、对象与其很相似，但是还有区别。
(2)集合的由来：对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定，就需要使用集合来进行存储。
(3)集合的特点：
a.用于存储对象的容器；即集合中存储的元素是对象
b.集合的长度是可变的；
c.集合是不可以存储基本数据类型的；（集合存储基本数据类型时会先进行自动封装成其对应的对象后再进行存储）

3、集合框架的顶层接口（根接口）：Collection
   Collection的常见方法：
   （1）添加
       boolean add(E o);
       boolean add(Collection<? extends E> c);
   （2）删除
       boolean remove(Object o);
       boolean removeAll(Collection<? extends E> c)
       void clear()；
   （3）判断
       a.判断集合中是否有元素：boolean isEmpty();
       b.判断集合中是否包含某个元素：boolean contains(Object o);
       c.判断集合中是否包含某些元素：boolean contains(Collection<?> c);

   （4）获取
       a.获取集合中元素个数：int size();
       b.遍历集合中所有元素：Iterator<E> iterator();
       c.判断两个集合中是否存在相同的元素并保留两个集合中相同的元素删除不同的元素：boolean retainAll(Collection<?> c);
   （5）其他
       将集合中元素转为数组：a.    Ojbect[] toArray();
                      b.    <T> T[] toArray();   泛型

4.、迭代器 Iterator
   （1）通过集合对象获取其对应的Iterator对象；
   （2）判断是否存在下一个元素；
   （3）取出该元素并将迭代器对象指向下一个元素；

Iterator iterator():取出元素的方式：迭代器。
       该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
       所以该迭代器对象是在容器中进行内部实现的。
       对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，也就是iterator方法。

4.1迭代器（Iterator）输出

public class collectionDemo {

//ArrayList

public  static  void testArrayList(){

//表示list 对象里面要存储的数据类型为String

ArrayList<String>list=new ArrayList<String>();

//1.增加元素

list.add("zhangsan");

list.add("李四");

list.add("王五");

list.add("张全蛋");

list.add("赵铁柱");

//2.向指定的位置添加

list.add(1,"赵铁柱");

// list.add(10,"王尼玛");//不能越界插入元素,因为没有这个位置

//4.通过迭代器  （Iterator）输出

  index=0;

Iterator<String> it = list.iterator();

while(it.hasNext()){

System.out.println("第"+(index++)+"个元素是："+it.next());

}

}

5.Collection两大体系：链表List、集合Set
   List特点：元素有序；元素可以重复；元素都有索引（角标）
   Set 特点：元素无序；元素不可以重复；

   List特有的常见方法：有一个共性就是可以操作角标。

6.List常用方法

package com.itlwc;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
List list = new ArrayList();
// 向列表的尾部追加指定的元素
list.add("lwc");
// 在列表的指定位置插入指定元素
list.add(1, "nxj");
// 追加指定 collection 中的所有元素到此列表的结尾
list.addAll(new ArrayList());
// 从列表中移除所有元素
list.clear();
// 如果列表包含指定的元素,则返回true
list.contains("nxj");
// 如果列表包含指定 collection 的所有元素,则返回 true
list.containsAll(new ArrayList());
// 比较指定的对象与列表是否相等
list.equals(new ArrayList());
// 返回列表中指定位置的元素
list.get(0);
// 返回列表的哈希码值
list.hashCode();
// 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.indexOf("lwc");
// 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.lastIndexOf("lwc");
// 如果列表不包含元素,则返回 true
list.isEmpty();
// 移除列表中指定位置的元素
list.remove(0);
// 移除列表中出现的首个指定元素
list.remove("lwc");
// 从列表中移除指定 collection 中包含的所有元素
list.removeAll(new ArrayList());
// 用指定元素替换列表中指定位置的元素
list.set(0, "lp");
// 返回列表中的元素数
list.size();
// 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图
list.subList(1, 2);
// 对于第一个重载方法，是将list直接转为Object[] 数组；
list.toArray();
//将list转化为你所需要类型的数组，当然我们用的时候会转化为与list内容相同的类型。
list.toArray(new String[] { "a", "b" });
}
}

6.1主要方法：

public boolean add(Object?o)：添加元素
public void add(int index, Object element)：在指定位置添加元素
public Iterator iterator()：取得Iterator对象便于遍历所有元素
public Object get(int?index)：根据索引获取指定位置的元素
public Object set(int index,Object element)：替换掉指定位置的元素

6.2 排序方法：

Collections.sort(List list)：对List的元素进行自然排序
Collections.sort(List list, Comparator comparator)：对List中的元素进行客户化排序

7.ArrayList

构造方法

public ArrayList()

public ArrayList(int initialCapacity)

public ArrayList(Collection c)

ArrayList依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组

当元素超过10,那么ArrayList底层会新生成一个数组,长度为原来的1.5倍+1,

然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中,

当新数组无法容纳增加的元素,重复该过程

ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,

因为操作之后后续元素需要移动

7.1ArrayList 遍历

package com.itlwc;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("lwc");
list.add("nxj");
// 方法一
Iterator<String> ite1 = list.iterator();
while (ite1.hasNext()) {
String str = ite1.next();
System.out.println(str);
}
System.out.println("---------------------");
// 方法二(方法一的变形)
for (Iterator<String> ite2 = list.iterator(); ite2.hasNext();) {
String str = ite2.next();
System.out.println(str);
}
System.out.println("---------------------");
// 方法三
for(String s : list){
System.out.println(s);
}
}
}

7.2ArraayList 代码实例

package com.rimi.week5_1;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

public class collectionDemo {

    //ArrayList

    public  static  void testArrayList(){

        //表示list 对象里面要存储的数据类型为String

        ArrayList<String>list=new ArrayList<String>();

        //1.增加元素

        list.add("zhangsan");

        list.add("李四");

        list.add("王五");

        list.add("张全蛋");

        list.add("赵铁柱");

        //2.向指定的位置添加

        list.add(1,"赵铁柱");

    //    list.add(10,"王尼玛");//不能越界插入元素,因为没有这个位置

        //3.输出、

    int    index=0;

        for (String string : list) {

            System.out.println("第"+(index++)+"个元素是："+string);

        }

        //4.通过迭代器  （Iterator）输出

          index=0;

        Iterator<String> it = list.iterator();

        while(it.hasNext()){

            System.out.println("第"+(index++)+"个元素是："+it.next());

        }

        //5.判断list里面是否包含有指定元素

        System.out.println("list里面有张全蛋："+list.contains("张全蛋"));

        System.out.println("list里面有王尼玛："+list.contains("王尼玛"));

        //6.得到某个元素在list 对象里面的位置

        System.out.println("list里面张全蛋的位置："+list.indexOf("张全蛋"));

        printList(list);

        System.out.println("list里面赵铁柱最后一次出现的位置是："+list.lastIndexOf("赵铁柱"));

        //7.移除list里面的元素

        System.out.println("list里面移除张全蛋是否成功："+list.remove("张全蛋"));

        System.out.println("list里面有张全蛋："+list.contains("张全蛋"));

        printList(list);

        //删除指定位置

        System.out.println("list 里面移除第一个："+list.remove(0));

        printList(list);

        //8.修改指定位置元素的值

        list.set(0,"王小花");

        printList(list);

    //9.subList 子表（0，2）从角标0开始到角标2结束（0包含2不包含）前闭后开

        List<String> list1 =list.subList(0,2);

        printList2(list1);

        //10.添加多个元素

        ArrayList<String> list2= new ArrayList<String>();

        list.add("王老2");

        list.add("大黄");

        list.addAll(list2);

        printList(list);

        //11.size // 返回列表中的元素数

        printList(list);

        System.out.println("list 里面有："+list.size()+"个元素");

        //12.isEmpty// 判断列表是否为空，是空就返回true

        System.out.println("list 是否为空："+list.isEmpty());

        //13.clear// 从列表中移除所有元素

        list.clear();

        System.out.println("list.clear()之后，list 是否为空："+list.isEmpty());

        //14.toArray// 返回以正确顺序包含列表中的所有元素的数组

        System.out.println(Arrays.toString(list.toArray()));

    }

    public static void printList2(List<String>list){

        int    index=0;

        for (String string : list) {

            System.out.println("第"+(index++)+"个元素是："+string);

        }

        System.out.println("-----------------");

        }

    public static void printList(Collection<String>list){

    int    index=0;

    for (String string : list) {

        System.out.println("第"+(index++)+"个元素是："+string);

    }

    System.out.println("-----------------");

    }

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        testArrayList();

    }

}

8.linkedList

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));

LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.
LinkedList的构造函数如下
1. public LinkedList(): ——生成空的链表
2. public LinkedList(Collection col): 复制构造函数
1、获取链表的第一个和最后一个元素
[java] view plaincopy
import java.util.LinkedList;

public class LinkedListTest{
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");

System.out.println("链表的第一个元素是 : " + lList.getFirst());
System.out.println("链表最后一个元素是 : " + lList.getLast());
}
}

2、获取链表元素
[java] view plaincopy
for (String str: lList) {
System.out.println(str);
}
3、从链表生成子表
[java] view plaincopy
List subl = lList.subList(1, 4);
System.out.println(subl);
lst.remove(2);
System.out.println(lst);
System.out.println(lList);
4、添加元素：添加单个元素
如果不指定索引的话，元素将被添加到链表的最后.
public boolean add(Object element)
public boolean add(int index, Object element)
也可以把链表当初栈或者队列来处理:
public boolean addFirst(Object element)
public boolean addLast(Object element)
addLast()方法和不带索引的add()方法实现的效果一样.
[java] view plaincopy
import java.util.LinkedList;

public class LinkedListTest{
public static void main(String[] a) {
LinkedList list = new LinkedList();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.addFirst("X");
list.addLast("Z");
System.out.println(list);
}
}
5、删除元素
[java] view plaincopy
public Object removeFirst()
public Object removeLast()
import java.util.LinkedList;

public class MainClass {
public static void main(String[] a) {

LinkedList list = new LinkedList();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.removeFirst();
list.removeLast();
System.out.println(list);
}
}
6、使用链表实现栈效果
[java] view plaincopy
import java.util.LinkedList;
public class MainClass {
public static void main(String[] args) {
StackL stack = new StackL();
for (int i = 0; i < 10; i++)
stack.push(i);
System.out.println(stack.top());
System.out.println(stack.top());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
class StackL {
private LinkedList list = new LinkedList();
public void push(Object v) {
list.addFirst(v);
}
public Object top() {
return list.getFirst();
}
public Object pop() {
return list.removeFirst();
}
}
7、使用链表来实现队列效果
[java] view plaincopy
import java.util.LinkedList;
public class MainClass {
public static void main(String[] args) {
Queue queue = new Queue();
for (int i = 0; i < 10; i++)
queue.put(Integer.toString(i));
while (!queue.isEmpty())
System.out.println(queue.get());
}
}
class Queue {
private LinkedList list = new LinkedList();
public void put(Object v) {
list.addFirst(v);
}
public Object get() {
return list.removeLast();
}
public boolean isEmpty() {
return list.isEmpty();
}
}
8、将LinkedList转换成ArrayList
[java] view plaincopy
ArrayList<String> arrayList = new ArrayList<String>(linkedList);
for (String s : arrayList) {
System.out.println("s = " + s);
}
9、删掉所有元素：清空LinkedList
lList.clear();
10、删除列表的首位元素
[java] view plaincopy
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println(lList);
//元素在删除的时候，仍然可以获取到元素
Object object = lList.removeFirst();
System.out.println(object + " has been removed");
System.out.println(lList);
object = lList.removeLast();
System.out.println(object + " has been removed");
System.out.println(lList);
}
}
11、根据范围删除列表元素
[java] view plaincopy
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println(lList);
lList.subList(2, 5).clear();
System.out.println(lList);
}
}
12、删除链表的特定元素
[java] view plaincopy
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println(lList);
System.out.println(lList.remove("2"));//删除元素值=2的元素
System.out.println(lList);
Object obj = lList.remove(2); //删除第二个元素
System.out.println(obj + " 已经从链表删除");
System.out.println(lList);
}
}
13、将LinkedList转换为数组，数组长度为0
[java] view plaincopy
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> theList = new LinkedList<String>();
theList.add("A");
theList.add("B");
theList.add("C");
theList.add("D");
String[] my = theList.toArray(new String[0]);
for (int i = 0; i < my.length; i++) {
System.out.println(my[i]);
}
}
}
14、将LinkedList转换为数组，数组长度为链表长度
[java] view plaincopy
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> theList = new LinkedList<String>();
theList.add("A");
theList.add("B");
theList.add("C");
theList.add("D");
String[] my = theList.toArray(new String[theList.size()]);
for (int i = 0; i < my.length; i++) {
System.out.println(my[i]);
}
}
}
15、将LinkedList转换成ArrayList
[java] view plaincopy
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
LinkedList<String> myQueue = new LinkedList<String>();
myQueue.add("A");
myQueue.add("B");
myQueue.add("C");
myQueue.add("D");
List<String> myList = new ArrayList<String>(myQueue);
for (Object theFruit : myList)
System.out.println(theFruit);
}
}
16、实现栈
[java] view plaincopy
import java.util.Collections;
import java.util.LinkedList;
public class Main {
public static void main(String[] argv) throws Exception {
LinkedList stack = new LinkedList();
Object object = "";
stack.addFirst(object);
Object o = stack.getFirst();
stack = (LinkedList) Collections.synchronizedList(stack);
}
}
17、实现队列
[java] view plaincopy
import java.util.LinkedList;
public class Main {
public static void main(String[] argv) throws Exception {
LinkedList queue = new LinkedList();
Object object = "";
// Add to end of queue
queue.add(object);
// Get head of queue
Object o = queue.removeFirst();
}
}
18 、同步方法
[java] view plaincopy
import java.util.Collections;
import java.util.LinkedList;
public class Main {
public static void main(String[] argv) throws Exception {
LinkedList queue = new LinkedList();
Object object = "";
queue.add(object);
Object o = queue.removeFirst();
queue = (LinkedList) Collections.synchronizedList(queue);
}
}
19、查找元素位置
[java] view plaincopy
import java.util.LinkedList;

public class Main {
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
lList.add("2");
System.out.println(lList.indexOf("2"));
System.out.println(lList.lastIndexOf("2"));
}
}
20、替换元素
[java] view plaincopy
import java.util.LinkedList;

public class Main {
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println(lList);
lList.set(3, "Replaced");//使用set方法替换元素，方法的第一个参数是元素索引，后一个是替换值
System.out.println(lList);
}
}
21、链表添加对象
[java] view plaincopy
import java.util.LinkedList;
class Address {
private String name;
private String street;
private String city;
private String state;
private String code;
Address(String n, String s, String c, String st, String cd) {
name = n;
street = s;
city = c;
state = st;
code = cd;
}
public String toString() {
return name + " " + street + " " + city + " " + state + " " + code;
}
}

class MailList {
public static void main(String args[]) {
LinkedList<Address> ml = new LinkedList<Address>();
ml.add(new Address("A", "11 Ave", "U", "IL", "11111"));
ml.add(new Address("R", "11 Lane", "M", "IL", "22222"));
ml.add(new Address("T", "8 St", "C", "IL", "33333"));
for (Address element : ml)
System.out.println(element + "\n");
}
}
22、确认链表是否存在特定元素
[java] view plaincopy
import java.util.LinkedList;

public class Main {
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
if (lList.contains("4")) {
System.out.println("LinkedList contains 4");
} else {
System.out.println("LinkedList does not contain 4");
}
}
}
23、根据链表元素生成对象数组
[java] view plaincopy
Object[] objArray = lList.toArray();
for (Object obj: objArray) {
System.out.println(obj);
}
24、链表多线程
[java] view plaincopy
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
class PrepareProduction implements Runnable {
private final List<String> queue;
PrepareProduction(List<String> q) {
queue = q;
}
public void run() {
queue.add("1");
queue.add("done");
}
}
class DoProduction implements Runnable {
private final List<String> queue;
DoProduction(List<String> q) {
queue = q;
}
public void run() {
String value = queue.remove(0);
while (!value.equals("*")) {
System.out.println(value);
value = queue.remove(0);
}
}
}
public class Main {
public static void main(String[] args) throws Exception {
List q = Collections.synchronizedList(new LinkedList<String>());
Thread p1 = new Thread(new PrepareProduction(q));
Thread c1 = new Thread(new DoProduction(q));
p1.start();
c1.start();
p1.join();
c1.join();
}
}
25、优先级链表（来自JBOSS）
[java] view plaincopy
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;

public class BasicPriorityLinkedList {

protected LinkedList[] linkedLists;
protected int priorities;
protected int size;

public BasicPriorityLinkedList(int priorities) {
this.priorities = priorities;
initDeques();
}
public void addFirst(Object obj, int priority) {
linkedLists[priority].addFirst(obj);
size++;
}
public void addLast(Object obj, int priority) {
linkedLists[priority].addLast(obj);
size++;
}
public Object removeFirst() {
Object obj = null;
for (int i = priorities - 1; i >= 0; i--) {
LinkedList ll = linkedLists[i];
if (!ll.isEmpty()) {
obj = ll.removeFirst();
break;
}
}
if (obj != null) {
size--;
}
return obj;
}
public Object removeLast() {
Object obj = null;
for (int i = 0; i < priorities; i++) {
LinkedList ll = linkedLists[i];
if (!ll.isEmpty()) {
obj = ll.removeLast();
}
if (obj != null) {
break;
}
}
if (obj != null) {
size--;
}
return obj;
}

public Object peekFirst() {
Object obj = null;
for (int i = priorities - 1; i >= 0; i--) {
LinkedList ll = linkedLists[i];
if (!ll.isEmpty()) {
obj = ll.getFirst();
}
if (obj != null) {
break;
}
}
return obj;
}

public List getAll() {
List all = new ArrayList();
for (int i = priorities - 1; i >= 0; i--) {
LinkedList deque = linkedLists[i];
all.addAll(deque);
}
return all;
}

public void clear() {
initDeques();
}

public int size() {
return size;
}

public boolean isEmpty() {
return size == 0;
}

public ListIterator iterator() {
return new PriorityLinkedListIterator(linkedLists);
}

protected void initDeques() {
linkedLists = new LinkedList[priorities];
for (int i = 0; i < priorities; i++) {
linkedLists[i] = new LinkedList();
}
size = 0;
}

class PriorityLinkedListIterator implements ListIterator {
private LinkedList[] lists;
private int index;
private ListIterator currentIter;
PriorityLinkedListIterator(LinkedList[] lists) {
this.lists = lists;
index = lists.length - 1;
currentIter = lists[index].listIterator();
}

public void add(Object arg0) {
throw new UnsupportedOperationException();
}

public boolean hasNext() {
if (currentIter.hasNext()) {
return true;
}
while (index >= 0) {
if (index == 0 || currentIter.hasNext()) {
break;
}
index--;
currentIter = lists[index].listIterator();
}
return currentIter.hasNext();
}

public boolean hasPrevious() {
throw new UnsupportedOperationException();
}

public Object next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return currentIter.next();
}

public int nextIndex() {
throw new UnsupportedOperationException();
}

public Object previous() {
throw new UnsupportedOperationException();
}

public int previousIndex() {
throw new UnsupportedOperationException();
}

public void remove() {
currentIter.remove();
size--;
}

public void set(Object obj) {
throw new UnsupportedOperationException();
}
}

}
26、生成list的帮助类（来自google）
[java] view plaincopy
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class Lists {
private Lists() { }
public static <E> ArrayList<E> newArrayList() {
return new ArrayList<E>();
}
public static <E> ArrayList<E> newArrayListWithCapacity(int initialCapacity) {
return new ArrayList<E>(initialCapacity);
}
public static <E> ArrayList<E> newArrayList(E... elements) {
ArrayList<E> set = newArrayList();
Collections.addAll(set, elements);
return set;
}
public static <E> ArrayList<E> newArrayList(Iterable<? extends E> elements) {
ArrayList<E> list = newArrayList();
for(E e : elements) {
list.add(e);
}
return list;
}
public static <E> LinkedList<E> newLinkedList() {
return new LinkedList<E>();
}
}

8.1 LinkedList 代码实例：

package week6;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class LinkedListdemo {
public static void main(String[] args) {
List<Comparable>li=createLinkedList();
//printList(createLinkedList());

//printList2(li);
li.add("hello world");
li.add(0,"张全蛋");
printList2(li);
System.out.println("li 里面有1？"+li.contains(1));
//删除
li.remove("zhangsan");
printList2(li);
li.remove(1);
printList2(li);
//修改
li.set(0,"张铁柱");
printList(li);
//判断是否为空
System.out.println("li 为空？"+li.isEmpty());
//清空
// li.clear();
System.out.println("li 为空？"+li.isEmpty());
//数组转换为List
arraysToList();
//list 是否可以转换成数组
Object[] oArr= li.toArray();
System.out.println("**********************");
System.out.println(oArr.length);
for (Object object : oArr) {
System.out.println(object);
}
}
//数组转换为List
public static void arraysToList(){
String[] strArr={"aaa","bbb","ccc","ddd","eee","fff"};
List l=Arrays.asList(strArr);
printList2(l);

}

public static void printList2(List<Comparable>li){
System.out.println("===========================");
ListIterator it=li.listIterator();
while(it.hasNext()){
System.out.println(it.next());
}
}

public static void printList(List<Comparable>li){
for (int i = 0; i < li.size(); i++) {
System.out.println(li.get(i));
}
}

public static List<Comparable> createLinkedList(){
List<Comparable> li=new LinkedList();
li.add(1);
li.add("zhangsan");
return li;
}
}

java collection(一)的更多相关文章

Java Collection开发技巧
Java Collection(集合) 集合中的一些技巧: 通过Collections类的静态方法,可以对集合进行一些操作 1 java.util.List<Integer> number ...
Java Collection Framework概述
文章出自:听云博客 Collection概述 Java collection是java提供的工具包,包含了常用的数据结构:集合.链表.队列.栈.数组.映射等. Java集合主要可以划分为4个部分:Li ...
Java Collection好文章
Java Collection好文章 http://my.oschina.net/xiaomaoandhong/blog/78394
java collection framework
java collection framework Map
Java Collection 集合类大小调整带来的性能消耗
Java Collection类的某些详细实现因为底层数据存储基于数组,随着元素数量的添加,调整大小的代价非常大.随着Collection元素增长到某个上限,调整其大小可能出现性能问题. 当Colle ...
Java Collection Framework : List
摘要: List 是 Java Collection Framework的重要成员,详细包括List接口及其全部的实现类.由于List接口继承了Collection接口,所以List拥有Collect ...
------------------java collection 集合学习 ----小白学习笔记，，有错，请指出谢谢
<!doctype html>java对象集合学习记录 figure:first-child { margin-top: -20px; } #write ol, #write ul { p ...
java Collection中的排序问题
java Collection中的排序问题这里讨论list.set.map的排序,包括按照map的value进行排序. 1)list排序 list排序可以直接采用Collections的sort方法 ...
Java集合框架介绍。Java Collection Frameworks = JCF
Java集合框架 = Java Collection Frameworks = JCF . 为了方便理解,我画了一张思维脑图.
JAVA collection集合之扑克牌游戏
主要内容:这里使用collection集合,模拟香港电影中大佬们玩的扑克牌游戏. 1.游戏规则:两个玩家每人手中发两张牌,进行比较.比较每个玩家手中牌最大的点数,大小由A-2,点数大者获胜.如果点数相 ...

随机推荐

Tarball——以源代码的方式安装软件
一.Tarball文件形成:将软件的所有源码文件先以tar打包,然后再以压缩技术(如gzip)来压缩.因为源码文件很大. 描述:一个软件包,解压缩后得到源代码文件.检测程序文件.软件的简易说明与安装 ...
Python学习之路5 - 函数
函数定义方式: def func(): "这里面写函数的描述" 这里写代码 return x #如果没有返回值就叫"过程",函数和过程的区别就是有无返回值实 ...
Thrift IDL使用方式
I.背景众所周知,Thrift是一个RPC的框架,其可用于不同语言之间的服务相互调用.比如最近接触到的一个运用环境: *前端使用Node.Js重构了部分我们的老旧代码(前后端未分离的SpringBo ...
C# 知识回顾 - 匿名方法
C# 基础回顾 - 匿名方法目录简介匿名方法的参数使用范围委托示例简介在 C# 2.0 之前的版本中,我们创建委托的唯一形式 -- 命名方法. 而 C# 2.0 -- 引进了匿名方法,在 ...
arp_ignore
上一篇文件说了arp_announce,那么到这里arp_ignore,我们直接看代码应该也比较容易立即了目前我知道的是arp_ignore = 0,只要IP是自己机器上的,都可以回复: 说实话就是 ...
第51天：封装可视区域大小函数client
一.client 可视区域 offsetWidth: width + padding + border (披着羊皮的狼) clientWidth: width + ...
asp.net mvc4 使用分部视图来刷新数据库
前几天研究SSE,用浏览器做侦听后台数据库数据变化,如果有更新,就即时通过浏览器,使用SSE效果果然OK,侦听数据库有更新时马上会向浏览器通知有新数据,我还在浏览器里放了短音提示,但遇到一个问题,发出 ...
BZOJ 1211 树的计数(purfer序列)
首先考虑无解的情况, 根据purfer序列,当dee[i]=0并且n!=1的时候,必然无解.否则为1. 且sum(dee[i]-1)!=n-2也必然无解. 剩下的使用排列组合即可推出公式.需要注意的是 ...
【bzoj4278】[ONTAK2015]Tasowanie 贪心+后缀数组
题目描述给定两个数字串A和B,通过将A和B进行二路归并得到一个新的数字串T,请找到字典序最小的T. 输入第一行包含一个正整数n(1<=n<=200000),表示A串的长度. 第二行包含 ...
css边框以及其他常用样式
1. 边框是1像素,实体的,红色的. <!DOCTYPE html> <html lang="en"> <head> <meta char ...

java collection(一)

6.2 排序方法：

java collection(一)的更多相关文章

随机推荐

热门专题