Java集合 ——(一)

集合的数目是可变的，并且集合只能存储引用数据类型的数据，不能存放基本数据类型的数据，集合类和数组相比有很多不同之处，比如，数组的长度是不可变的，而集合的长度是可变的，而集合的长度是可变的；数组可以用来存储基本数据类型的数据，也可以存放引用类型的数据，而集合只能存放引用类型的数据，不能存放基本类型的数据。
这里写图片描述

List接口

List接口是一个有序集合，其元素以线性方式存储，集合中允许存放重复的元素。

List接口的定义如下：

public interface List<E> extends Collection<E> { }

数组列表类：ArrayList

ArrayList类的定义如下：

public class ArrayList<E> extends AbstrctList<E> implements List<E>,RandomAccess,Cloneable,Serializable { }

ArrayList类实现List接口，可以直接通过ArrayList为List接口实例化。ArrayList类是数组列表类，实现了可变长度的数组，允许对集合中的元素进行快速的访问，但向ArrayList集合中插入和删除数据速度比较慢。

ArrayList集合中，插入一个元素时，列表需要将插入点后面的所有元素向后移动，而在删除一个元素时，需要将被删除元素的后面的所有元素向前移动，无论是插入还是删除，平均耗时为n/2

ArrayList集合允许所有的元素包括null.

每一个ArrayList实例都有一个默认的容量(10个)，即存储元素的个数，这个容量可以随着元素的增加而自动变大(每次是原分配空间的1.5倍)。源码如下：
这里写图片描述

1.向集合添加元素

在Collection接口就已经定义了向集合添加元素的方法，add()和addAll(）

package study;
        import java.util.Collection;
        import java.util.List;
        import java.util.ArrayList;
        public class Lianxi1 {
            public static void main(String[] args) {
                Collection<String> collection = new ArrayList<String>();        //通过ArrayList实例化Collection
                List<String> list = new ArrayList<String>();                    //通过ArrayList实例化List
                collection.add("1");                                            //添加元素          
                collection.add("2");                                            //添加元素  
                collection.add("3");                                            //添加元素  
                System.out.println("collection集合："+collection);             //打印集合中的元素
                list.add("A");                                                  //添加元素  
                list.add("C");                                                  //添加元素  
                list.add(1,"B");                                                //向指定位置添加元素 
                list.addAll(0,collection);                                      //向指定位置添加一个集合的所有元素
                System.out.println("list集合："+list);                             //打印集合中的元素
            }
}

collection集合：[1, 2, 3]
list集合：[1, 2, 3, A, B, C]

add(E o)只是在集合的最后进行内容的追加，而add(int index,E element)可以在指定位置添加。

2.删除集合中的元素

ArrayList集合提供了专门用于删除元素的方法，Collection接口提供了remove()和removeAll()方法，在List接口中还提供了可以删除指定位置元素的方法remove(int index).

package study;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
public class Lianxi1 {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<String>();    //通过ArrayList实例化Collection
        List<String> list = new ArrayList<String>();                //通过ArrayList实例化List
        collection.add("1");                                        //添加元素          
        collection.add("2");                                        //添加元素  
        collection.add("3");                                        //添加元素  
        System.out.println("collection集合："+collection);
        list.add("A");                                              //添加元素  
        list.add("C");                                              //添加元素  
        list.add(1,"B");                                            //向指定位置添加元素 
        list.addAll(0,collection);                                  //向指定位置添加一个集合的所有元素
        System.out.println("list集合删除前："+list);
        list.remove("B");                                           //删除元素B
        list.remove(3);                                             //删除指定位置的元素
        list.removeAll(collection);                                 //删除指定集合的元素
        System.out.println("list集合删除后："+list);
    }
}

collection集合：[1, 2, 3]
list集合删除前：[1, 2, 3, A, B, C]
list集合删除后：[C]

3.集合的其他操作

package study;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
public class Lianxi1 {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<String>();    //通过ArrayList实例化Collection
        List<String> list = new ArrayList<String>();                //通过ArrayList实例化List
        collection.add("1");                                        //添加元素          
        collection.add("2");                                        //添加元素  
        collection.add("3");                                        //添加元素  
        list.add("A");                                              //添加元素  
        list.add("C");                                              //添加元素  
        list.add(1,"B");                                            //向指定位置添加元素 
        list.addAll(0,collection);                                  //向指定位置添加一个集合的所有元素
        System.out.println("list集合："+list);
        List<String> subList=list.subList(1,5);                     //截取集合
        System.out.println("subList集合："+subList);       
        System.out.println("设置list集合元素前：："+list.get(3));    //获取指定位置的元素
        list.set(3,"Set");                                          //设置指定位置的元素
        System.out.println("设置list集合元素后：："+list.get(3));    //获取指定位置的元素
        System.out.println("list集合中，元素3的位置："+
            list.indexOf("3")+"，元素D的位置："+list.indexOf("D"));    //获取指定元素在集合中的索引位置，若不存在则返回-1
        String arrString[] =list.toArray(new String[]{});           //将集合转为字符串数组
        for (String str : arrString){                               //输出数组元素
            System.out.print(str+"  ");
        }
        System.out.print("\nlist集合是否为空："+list.isEmpty());   //判断集合是否为空
        list.clear();                                               //清除集合中的所有元素
        System.out.println("\nlist集合是否为空："+list.isEmpty()); //判断集合是否为空
    }
}

4.交集、并集和差集

这里写图片描述

package com.tulun.jihe;

import java.util.ArrayList;

/**
 * @author lzq
 *
 */
public class ArrayListDemo {
    /**
     * @param args
     * 
     */

    public static void main(String[] args) {
        ArrayList<Integer> arraylist = new ArrayList<Integer>();
        arraylist.add(8);
        arraylist.add(9);
        ArrayList<Integer> arraylist2 = new ArrayList<Integer>();
        arraylist2.add(9);
        arraylist2.add(10);
        ArrayList<Integer> arraylist3 = new ArrayList<Integer>();
        //并集
        for(int i = 0;i < arraylist.size();i++) {
            arraylist3.add(arraylist.get(i));
        }
        for(int i = 0;i < arraylist2.size();i++) {
            arraylist3.add(arraylist2.get(i));
        }
        for(int i:arraylist3) {
            System.out.print(i+" ");
        }
        System.out.println();
        //交集
        for(int i = 0;i < arraylist.size();i++) {
            if(arraylist2.contains(arraylist.get(i))) {
                System.out.print(arraylist.get(i));
            }
        }
        System.out.println();
        //差集
        arraylist.removeAll(arraylist2);
        for(int i = 0;i < arraylist.size();i++) {
            if(!arraylist2.contains(arraylist.get(i))) {
                System.out.print(arraylist.get(i));
            }
        }
        System.out.println();
        for(int i = 0;i < arraylist.size();i++) {
            if(!arraylist.contains(arraylist2.get(i))) {
                System.out.print(arraylist2.get(i));
            }
        }






//      arraylist.add(1, 19);
//      ArrayList<Integer> arraylist1 = new ArrayList<Integer>();
//      for(int i = 0;i < arraylist.size();i++) {
//          System.out.print(arraylist.get(i)+" ");
//      }
//      arraylist1.add(93);
//      arraylist1.add(49);
//      arraylist.clear();
//      arraylist1.addAll(arraylist);
//      for(int i = 0;i < arraylist.size();i++) {
//          System.out.print(arraylist.get(i)+" ");
//      }
//      System.out.println("==========");
//      for(int i = 0;i < arraylist1.size();i++) {
//          System.out.print(arraylist1.get(i)+" ");
//      }
//      System.out.println();
        }
}

链表类：LinkedList类

LinkedList是链表类，采用链表结构保存元素。链表结构的优点是便于向集合插入和删除元素。因为在插入或删除元素时，不需要移动任何元素。但若需要随机访问集合中的元素时，LinkedList集合就显得比较慢了。
LinkedList类的定义如下：

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>,Queue<E>,Cloneable<E>,Serializable { }

LinkedList实现了List类，可以存在null元素，LinkedList类还提供了很多方法，这些方法可以使LinkedList类作为堆栈、队列或双向队列。

这里写图片描述

1.在链表的开头或结尾增加数据

可以通过LinkedList类的addFirst()和addLast()方法，将元素分别添加到链表的开头和结尾处

package study;
import java.util.List;
import java.util.LinkedList;
public class Lianxi1 {
    public static void main(String[] args) {
        LinkedList<String> link=new LinkedList<String>();
        link.add("1");                                      //添加元素
        link.add("2");                                      //添加元素
        link.add("3");                                      //添加元素
        System.out.println("添加前："+link);
        link.addFirst("F");                                 //添加元素在链表开头处
        link.addLast("L");                                  //添加元素在链表结尾处
        System.out.println("添加后："+link);
    }
}

添加前：[1, 2, 3]
添加后：[F, 1, 2, 3, L]

需要注意的是List接口中没有定义addFirst()和addLast()方法，所以不能使用：

List<String> link = new LinkedList<String>();

而是直接使用LinkedList类实现

2.区分获取表头的各个方法

在使用LinkedList类时，最常用的操作时获取表头，LinkedList类也提供了几个获取表头的方法，但他们的作用并不相同：

getFirst()：仅仅是获取表头
element()：获取但不移除此链表头
peek()：获取但不移除此链表头
poll()：获取并移除此链表头
pop()：获取并移除此链表头

package study;
import java.util.List;
import java.util.LinkedList;
public class Lianxi1 {
    public static void main(String[] args) {
        LinkedList<String> link=new LinkedList<String>();
        link.add("1");                                      //添加元素
        link.add("2");                                      //添加元素
        link.add("3");                                      //添加元素
        link.addFirst("F");                                 //添加元素在链表开头处
        link.addLast("L");                                  //添加元素在链表结尾处
        LinkedList<String> newLink=new LinkedList<String>(link);
        System.out.println("添加元素后：\n\t"+link);
        System.out.println("get()方法获取表头："+link.getFirst());
        System.out.println("使用get()方法后：\n\t"+link);
        System.out.println("element()方法获取表头："+link.element());
        System.out.println("使用element()方法后：\n\t"+link);
        System.out.println("peek()方法获取表头："+link.peek());
        System.out.println("使用peek()方法后：\n\t"+link);
        System.out.println("poll()方法获取表头："+link.poll());
        System.out.println("使用poll()方法后：\n\t"+link);
        System.out.println("pop()方法获取表头："+link.pop());
        System.out.println("使用pop()方法后：\n\t"+link);
        System.out.println("****使用链表的先进先出*****");
        int len=newLink.size();
        for (int i=0;i<len;i++ ){
            System.out.print(newLink.poll()+"  ");
        }
        System.out.println();
    }
}

添加元素后：
    [F, 1, 2, 3, L]
get()方法获取表头：F
使用get()方法后：
    [F, 1, 2, 3, L]
element()方法获取表头：F
使用element()方法后：
    [F, 1, 2, 3, L]
peek()方法获取表头：F
使用peek()方法后：
    [F, 1, 2, 3, L]
poll()方法获取表头：F
使用poll()方法后：
    [1, 2, 3, L]
pop()方法获取表头：1
使用pop()方法后：
    [2, 3, L]
****使用链表的先进先出*****
F  1  2  3  L

ArrayList和LinkedList的区别：

ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
对随机访问(get()(查)和set()(改))来说，ArrayList优于LinkList,是因为LinkList要移动指针。
对于add()(增)和remove()(删)，LinkedList相对于ArrayList是有优势的，因为后者需要移动数据