JAVA类之集合 important

集合： 相当于一个容器，只存储对象，长度可以改变 ；

数组：也相当一个容器，存储对象、基本数据类型，长度不可变 ；

首先先写一下集合的概念：容纳不同种类的数据建立在未知的基础之上，即java要用有限种类的集合类来容纳无限种类的数据对象；

其实集合类就相当于一个容器；用于存放对象的，而且长度可变；

java中的集合类分为三个类：集（Set）、列表(List)、映射(Map)；

集(Set)：元素无序、不包含重复元素；

列表(List):有序、包含重复元素  通过角标操作；

映射(Map):待续。。。。。；

忘了写了重要的一点；java.util.Collection接口是最基本的集合接口，是描述集合Set和列表List类型的跟接口；

                     

                Set-------HashSet

Collection-----

                          LinkedList

               List------

                          Vector------Stack

Map------Hashtable----Properties

Collection接口中的普遍性方法：

      

          public  boolean  add(E e):向集合添加一个元素，加入成功返回true，否则返回false；、

          

          public  boolean  remove（Object o）:从元素中删除指定的元素，删除成功返回true，否则false；

          public  void  clear():删除集合中的所有元素；

  

          public  boolean contains(Object o):判断集合是否包含指定元素；

 

          public  Object[] toArray() :返回包含当前集合中所有元素的数组。

          public  boolean  isEmpty()：判断集合是否为空；

          public  int  size：返回集合中的元素个数；

/*

集合：就是一个容器。

1，用于存储对象的。

2，该容器的长度是可变的。

因为装对象的容器内部的数据结构不同，

这些容器很很多中，经过了不断的抽取，就形成了体系。

这个体系我们称之为集合框架。

当我们学习一个体系的时候，

先要明确该体系的基本功能。

演示Collection中的方法。

*/

import java.util.*;

class ArrayListDemo

{

public static void main(String[] args)

{

//1,通过Collection的子类对象，创建一个容器。其实集合对象中存放都是元素的引用(地址)

ArrayList al = new ArrayList();

//2,可以Collection的共性方法添加一些元素。

al.add("abc1");

al.add("abc2");

al.add("abc3");

al.add("abc4");

ArrayList al1 = new ArrayList();

al1.add("qq1");

al1.add("qq2");

al1.add("qq3");

//al1.add("abc1");

//添加一堆元素。

//al.addAll(al1);

//3,删除一个元素。

al.remove("abc3");

//4,交集。

//boolean b = al.retainAll(al1);

//System.out.println("b="+b);

//5，清空集合。

//al.clear();

//获取集合的长度。

//6,判断一个元素。其实用的还是equals方法。判断元素是否相同。

//boolean b = al.contains("abc22");

//System.out.println("b="+b);

//System.out.println(al.size());

iteratorDemo();

//System.out.println(al.toString());//[abc1, abc2, abc4]

/*

Iterator it = al.iterator();

while(it.hasNext())

{

System.out.println(it.next()+"..");

}

al.retainAll(al1);

Iterator it1 = al.iterator();

while(it1.hasNext())

{

System.out.println(it1.next()+"--");

}

*/

}

public static void iteratorDemo()

{

ArrayList al = new  ArrayList();

al.add("abc1");

al.add("abc2");

al.add("abc3");

al.add("abc4");

/*

什么是迭代器？

就是用于取出集合中元素的对象。

该对象因为每一个容器的数据结构不同，所以实现方式也不一样，而且

迭代器是容器中的内容，所以是通过内部类来实现，也即是进行了容器内部封装。

我们只要通过iterator()方法获取该对象即可操作容器中的元素。

迭代器就如同大型游戏机中的抓布娃娃的游戏机，迭代器就是该游戏机中的那个夹子！

*/

Iterator it = al.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

for(Iterator it1 = al.iterator(); it1.hasNext(); )

{

System.out.println(it1.next());

}

// System.out.println(it.next());

// System.out.println(it.next());

// System.out.println(it.next());

// System.out.println(it.next());

// System.out.println(it.next());//.NoSuchElementException

}

}

/*

建立两个容器，A B

分别给容器中添加元素。

要求：获取A容器中的与B容器交集的元素，

将这些元素打印。

*/

首先讲一下列表List：

  List集合有ArrayList、LinkList、Vector；

      List方法：

            void add(int index,E element):在索引号index后插入element对象。

            boolean add（E e）:将对象e插入到链表的最后；

            E remove(int index)：删除链表里指定索引号的元素；

            boolean remove(Object o):删除链表里的第一个指定内容的元素；

 

            E get(int index):得到链表里的指定索引号的元素；

            int size():返回链表里的元素的个数；

 

            int indexOf(Object obj)：如果在链表里找到了obj元素，则返回这个元素的索引值；如果找不到返回-1；

            List<E> subList(int fromIndex，int toIndex)：得到链表里的从formindex开始，到toIndex结束的子链表；

           void  clear():将链表里的存储的元素全部清除掉；

该示例演示的是List接口中的特有方法。

可以通过角标操作元素的方法。

*/

import java.util.*;

class  ArrayListDemo2

{

public static void main(String[] args) 

{

ArrayList al = new ArrayList();

al.add("abc1");

al.add("abc2");

al.add("abc3");

System.out.println(al);

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

//1,在指定位置添加元素。

al.add(1,"haha");

//2,修改指定位置的元素。

al.set(2,"qq");

//3，删除指定位置的元素。

al.remove(0);

//4，获取指定元素的位置。

int index = al.indexOf("qq");

System.out.println("index="+index);

//5,获取子列表。

List ll = al.subList(1,2);

System.out.println("ll:"+ll);

//6,获取元素。

for(int x=0; x<al.size(); x++)

{

System.out.println("get("+x+"):"+al.get(x));

}

System.out.println(al);

}

}

实例：ArrayList

构造方法 

ArrayList() 

          构造一个初始容量为 10 的空列表。 

ArrayList(Collection<? extends E> c) 

          构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。 

ArrayList(int initialCapacity) 

          构造一个具有指定初始容量的空列表。 

方法：（上面重复的太多，只写他新增的了）

 int lastIndexOf(Object o) 

          返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。 

 E remove(int index) 

          移除此列表中指定位置上的元素。 

 boolean remove(Object o) 

          移除此列表中首次出现的指定元素（如果存在）。 

protected  void removeRange(int fromIndex, int toIndex) 

          移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。 

void trimToSize() 

          将此 ArrayList 实例的容量调整为列表的当前大小。 

 import java.util.*;

class CollectionDemo

{

public static void main(String[] args) 

{

ArrayList arr=new ArrayList();

arr.add("abc1");

arr.add("abc2");

arr.add("abc3");

arr.add("abc4");

System.out.println(arr.size());

arr.remove("abc3");

arr.clear();

System.out.println(arr.contains("abc3"));

System.out.println(arr);

         }

}

LinkedList类：

构造方法：

LinkedList() 

          构造一个空列表。 

LinkedList(Collection<? extends E> c) 

          构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。 

普通方法：

 

 void addFirst(E e) 

          将指定元素插入此列表的开头。 

 void addLast(E e) 

          将指定元素添加到此列表的结尾。 

 void clear() 

          从此列表中移除所有元素。 

 boolean contains(Object o) 

          如果此列表包含指定元素，则返回 true。 

 E element() 

          获取但不移除此列表的头（第一个元素）。 

 E get(int index) 

          返回此列表中指定位置处的元素。 

 E getFirst() 

          返回此列表的第一个元素。 

 E getLast() 

          返回此列表的最后一个元素。 

 int indexOf(Object o) 

          返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 

 int lastIndexOf(Object o) 

          返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 

 ListIterator<E> listIterator(int index) 

          返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。 

 E remove() 

          获取并移除此列表的头（第一个元素）。 

 E remove(int index) 

          移除此列表中指定位置处的元素。 

 boolean remove(Object o) 

          从此列表中移除首次出现的指定元素（如果存在）。 

 E removeFirst() 

          移除并返回此列表的第一个元素。 

import java.util.*;

class LinkedListDemo 

{

public static void main(String[] args) 

{

LinkedList link=new LinkedList();

link.addFirst("abc1");

link.addFirst("abc2");

link.addFirst("abc3");

link.addFirst("abc4");

while(!link.isEmpty()){

System.out.println(link.removeFirst());

}

}

}

/*输出

abc4

abc3

abc2

abc1*/

未完。。。。。。。。待续。。。。。。