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;
}
}