java 集合

Java集合，数目是可变的，并且集合只能存储引用数据类型，不能放基本类型
所有集合类都存放在 java.util包中，所以使用集合时，需要导入该包
集合又称为类集或容器
Java中的集合类主要由两个接口派生：Collection/Map
Collection接口派生了 List, Set集合
定义形式如下：
public interface Collection<E> extends Interable<E>

Collection 接口的方法定义

//向集合插入一个元素
public boolean add(E o)

//向集合添加一个集合 c 的所有元素
public boolean addAll(Collection<? extends E> c)

//清除集合中所有的元素
public void clear()

//判断集合中是否存在指定的元素。若存在，则返回 true,否则返回 false
public boolean contains(Object o)

//判断集合中是否存在指定的集合 c 的所有元素，若存在，则返回 true，否则为 false
public boolean containsAll(Collection<?> c)

//比较两个集合是否相等
public boolean equals(Object o)

//返回此 collection 的哈希值
public int hashCode()

//判断此集合是否为空。若为空，则返回 true,否则返回 false
public boolean isEmpty()

// 为 Iterator接口实例化，用于遍历集合中的元素
public Iterator<E> iterator()

//从集合中删除指定的元素
public boolean remove(Object o)

//从集合中删除指定集合c中出现的所有元素
public boolean removeAll(Collection<?> c)

//从集合中删除指定集合 c 中出现的所有元素
public boolean retainAll(Collection<?> c)

//返回此集合中的元素个数
public int size()

//返回包含此元素中所有元素的对象数组
public Object[] toArray()

//返回追念此元素中所有元素的数组，并可以指定返回的数组类型

一般情况下，不会直接操作 Collection 接口，而是调用其子接口：
List<E>:集合中的元素按照索引值来排序，允许存放重复的元素

Queue<E>:队列接口，以 先进先出的方式排序

Set<E>:集合中的元素不按特定方式排序，不能存放重复的，但是用别的方法实现排序

SortedSet<E>:可以对集合中的元素进行排序
public <T> T[] toArray(T[] a)

List 接口，主要有两个实现类： ArrayList 和 LinkedList

List接口的定义如下：
public interface List<E> extends Collection<E>
常用方法：

//在集合的指定位置插入一个元素
public void add(int index, E element)

//在集合的指定位置插入集合 c 的所有元素
public boolean addAll(int index, Collection<? extends E> c)

//返回此集合中指定位置的元素
public E get(int index)

//返回此集合中首次出现指定元素的索引，如果不存在，则返回 -1
public int indexOf(Object o)

//返回此集合中最后出现指定元素的索引，如果没有，则返回 -1
public int lastIndexOf(Object o)

//为 ListIterator接口实例化，用于遍历集合中的元素
public ListIterator<E> listIterator()

//同上，只是按指定的位置开始
public ListIterator<E> listIterator(int index)

//删除指定位置的元素
public E remove(int index)

//替换指定位置的元素
public E set(int index, E element)

//返回一个新的元素集合，包含从指定的位置到指定的位置元素
public List<E> subList(int fromIndex, int toIndex)

数组列表类  ArrayList类

//增加数组的容量
public void ensureCapacity(int minCapacity)

//删除集合中索引在 fromIndex(包括)和toIndex(不包括)之间的所有元素
protected void removeRange(int fromIndex, int toIndex)

//调整为恰当的大小
public void trimSize()

//向集合中添加元素
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
public class Hi
{
    public static void main(String[] args)
    {
        // 通过 ArrayList实例化 Collection
        Collection<String> collection = new ArrayList<String>();
        //通过 ArrayList实例化 list
        List<String> list = new ArrayList<String>();
        //添加元素
        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]
*/

// 删除集合中的元素
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
public class Hi
{
    public static void main(String[] args)
    {
        // 通过 ArrayList实例化 collection
        Collection<String> collection = new ArrayList<String>();
        //通过 ArrayList 实例化 List
        List<String> list = new ArrayList<String>();
        //添加元素
        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);
        //删除元素 B
        list.remove("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]
*/
// 集合的其他操作
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
public class Hi
{
    public static void main(String[] args)
    {
        // 通过 ArrayList实例化 collection
        Collection<String> collection = new ArrayList<String>();
        //通过 Arraylist实例化 List
        List<String> list = new ArrayList<String>();
        //添加元素
        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));
        // 获取指定元素在集合中的索引位置，若不存在，则返回 -1
        System.out.println("list集合中，元素3的位置："+list.indexOf("3")+",元素D的位置："+list.indexOf("D"));
        // 将集合转为字符串数组
        String arrString[] = list.toArray(new String[]{});
        for(String str: arrString)
        {
            System.out.println(str+" ");
        }
        //判断集合是否为空
        System.out.println("\nlist集合是滞为空："+list.isEmpty());
        //清除集合中的所有元素
        list.clear();
        System.out.println("\nlist集合是为空："+list.isEmpty());
    }
}
/*
list集合：[1, 2, 3, A, B, C]
subList集合：[2, 3, A, B]
设置list集合元素前：：A
设置list集合元素后：：set
list集合中，元素3的位置：2,元素D的位置：-1
1
2
3
set
B
C

list集合是滞为空：false

list集合是为空：true
*/
链表类 LinkedList 类
是用 链表结构保存元素
常用方法：
public void addFirst(E o)
public void addLast(E o)
public Iterator<E> descendingIterator()
public E element()
public E get(int index)
public E getFirst()
public E getLast()
public int indexOf(Object o)
public int lastIndexOf(Object o)

public ListIterator<E> listIterator(int index)
public boolean offer(E o)
public boolean offerFirst(E e)
public boolean offerLast(E e)

public E peek()
public E peekFirst()
public E peekLast()

public E poll()
public E pollFirst()
public E pollLast()
public E pop()
public void push(E e)
public E remove()

public E remove(int index)
public boolean remove(Object o)
public E removeFirst()
public boolean removeFirstOccurrence(Object o)
public E removeLast()
public boolean removeLastOccurrence(Object o)
public E set(int index, E element)

//在链表开头和结尾增加数据
import java.util.List;
import java.util.LinkedList;
public class Hi
{
    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]
*/
获取链表头
import java.util.List;
import java.util.LinkedList;
public class Hi
{
    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"+link);
        System.out.println("get()方法获取表头:"+link.getFirst());
        System.out.println("使用 get()方法后：\n"+link);
        System.out.println("element()方法获取表头:"+link.element());
        System.out.println("使用element()方法后：\n"+link);
        System.out.println("peek()方法获取表头："+link.peek());
        System.out.println("使用peek()方法后："+link);
        System.out.println("poll()方法获取表头:"+link.poll());
        System.out.println("使用poll()方法后："+link);
        System.out.println("pop()方法获取表头："+link.pop());
        System.out.println("使用pop()方法后："+link);
        System.out.println("\n********************\n");
        int len = newLink.size();
        for(int i=0; i<len; i++)
        {
            System.out.print(newLink.poll()+"\t");
        }
        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
*/