Java开发知识之Java中的集合上List接口以及子类讲解.

　　　　　　　　　　　　Java开发知识之Java中的集合类

一丶什么是集合类

　　如果你学习说数据结构,那么学习集合就很简单. 因为集合就是存储数据的结构. 例如 有链表结构 (list ) 还有 map结构.等等. 

集合类就是存储数据的集合.

我们可以看一下继承图:

　　

Collection接口. 由 Set类.以及 List类就行实现. 并且还有子类. 

Map 有 HashMap类. 还有 TreeMap类继承. 各个类都是不一样的.比如 List.代表链表类.可以存储数据,是连续的.只要有前驱后继即可. 子类就是对链表进行了限制而已.

二丶Collection接口

　　每次学习一个类的时候.都要从它的顶层开始学习.比如我们学习list类.那么首先就要看他的父类.父类是否还有父类.因为公共父类是Object,所以我们就不介绍了.直接介绍Conllection接口

这个接口.是层级结构中的根接口. 构成Collection的单位称为元素.Collection通常是不能直接使用的.但是这个接口提供了 添加元素. 删除元素. 管理数据的方法. List 跟 Set接口.都继承了Collection接口.所以她们也都默认有这些方法.

Collection中的接口方法

集合中的元素遍历就是用迭代器进行遍历. iterator. 其实如果学习C++.我们可以知道.其实迭代器就是内部类.对其隐藏了实现方法.

遍历代码如下:

　　

    public static void main(String[] args) throws MyException {
        
        Collection<String> a = new ArrayList<String>();
        a.add("1");
        a.add("2");
        a.add("3");
        a.add("2");
        a.add("2");
        a.add("2");
        
        //进行遍历
        ShowPrint(a);
    }

    private static void ShowPrint(Collection<String> a) {
        java.util.Iterator <String> it = a.iterator();
        while( it.hasNext()) {
            
            System.out.println(it.next());
        }
    }

在这里遍历的时候需要注意的问题:

　　1.调用集合的迭代方法的时候.会返回一个迭代类的对象. 也就是Iterator

　　2.迭代类中提供了三个方法.  hasNext()  it.next() it.remove 

　　　　分别是判断是否有元素.

　　　　取下一个元素.

　　　　删除元素.

　　我们需要注意的是,在遍历的时候. 首先要调用hasNext() 判断当前是否有元素. .还要调用的就是 next 指向下一个元素. it.next两个作用. 第一个,指向下一个元素. 第二个. 返回上一个元素的值.

it.next返回的对象是 Object对象. 我们可以进行强转. 如果是用泛型就是指定了.可能返回对象就是你的泛型对象.

三丶List接口

　　从上面的类的继承图可以看到. List接口实现了Collection接口. 所以List接口中 包含了Collection接口的方法. 但是List接口还提供了两个重要的方法.

get(int index): 获取指定索引位置的元素

set(int index,Object obj); 将集合中指定索引位置的对象修改为指定的对象.

提供了Set get方法.

因为添加了两个重要方法.所以List接口有两个类实现了它.分别有不同的作用

ArrayList类: 这个类就是可变的数组. 我们定义的数组都是死的.new多大就是多大.它是可以变得. 跟数组一样用.就是可以自动变.我们自己也可以封装.在C++中就是STL的 vcteor. 

作用: 可以进行快速的随机访问. 缺点就是向指定索引位置插入或者删除对象慢. 原因:

　　如果学过C++ 并且自己封装就知道.其实当你数据超过数组最大位置的时候.而是释放这块内存.重新申请一块大内存.并且拷贝原有数据. 然后插入到指定位置的时候.,还需要遍历数组. 移动元素. 所以底层做了很多.所以这就是慢的原因.

LinkedList类: 这个类就是我们传统意义上的链表的. 链表我们知道. 插入跟删除 快. 随机访问就慢了.

原因: 数组有 [] 使用这个给个索引就可以访问.但是链表不可以.链表只有遍历去寻找才可以.所以找的慢. 但是你插入跟删除快. 因为它断开链表指向下一个就行.

List接口的用法:

　　通常使用List接口.都是使用实例化类去实例化这个接口.所以一般写作

list<String> a = new ArrayList<String>();  当然String我们可以是任意数据类型.合法的就行.我们学过泛型应该知道什么意思.

list<String> a = new LinkedList<String>(); 

一般代码就是如上.

ArrayList类常用方法

　　1.增加

　　不管是ArrayList 以及 LinkedList类. 其实都是管理数据的. 对数据的增删改查, 既然底层已经使用数据结构的手法给我们封装好了.所以我们只需要熟悉方法即可.

如果想深入.可以看一下源码. 或者学习下数据结构思想. 数据结构很重要的一门课程.

添加方法:

　　

添加方法分别就是 Add()  Add(索引.对象) AddAll(); 

反正万变不离其宗就是添加.或者给索引我去添加. 等等.

public static void main(String[] args) throws MyException {
        
        List<String > a = new ArrayList<>();
        Collection<String> b = new ArrayList<>();
        b.add("1");
        
        a.add("1");
        a.add(0, "2");
        a.addAll(b);//添加的是实现了Collection的子类即可.
        
        //进行遍历
        ShowPrint(a);
    }

    private static void ShowPrint(Collection<String> a) {
        java.util.Iterator <String> it = a.iterator();
        while( it.hasNext()) {
            
            System.out.println(it.next());
        }
    }

结果:

　　

List接口的遍历

　　

    for( int i = 0; i < a.size();i++) {
            System.out.print( " " + a.get(i));
        }

list接口因为提供了get方法. 所以我们可以使用 size()获取集合元素个数. 然后获取指定元素索引位置的值.

2.删除

　　

对于ArrayList 类. 它的删除方法有三个.还有一个单独的. clean(); 这个方法是清除集合中的所有元素.

1.删除指定索引位置的值.  remove

2.给定一个对象.删除这个对象则集合中首次出现位置的对象. remove(object o)

3.给定一个范围.删除这个范围内的所有元素.  removeRange();

具体不测试了.

3.ArrayList 判断跟拷贝.

　　判断为空

       boolean  isEmpty(): 为空返回True

　　Object o clone(); 克隆.拷贝一个Arraylist副本. 使用Object对象接受.我们可以向下转型.

　　public boolean contains(Object o); 给定一个元素.判断这个元素是否则这个集合中.如果有返回true

4.ArrayList的元素查找.

　　

public int indexOf(Object o); 返回对象首次出现在集合的位置.
public int lastindexof(Object o): 从后往前查找.找出从后往前第一个出现元素的位置.

LinkedList类

　　linkedlist类.当做链表使用.所以方法都是操作方法的.

如果我们使用 List<E> a = new LinkedList<>(); 这种形式.

我们只需要学习 接口 List跟 LinkedList公共的方法即可.

1.增加:

　　addFrist();

　　addLast();

　　push(E e); 压入一个元素,其实就是头部添加元素.

E　　pop()  ;从头部弹出一个元素.而且这个元素弹出就没有了.

两个方法.一个往头添加元素.一个是尾.

2.迭代

　　iterator<E> descendingIterator(); 返回尾元素的迭代器.就是从尾巴遍历.

　　iterator<E> listIterator(); 返回头的迭代器.从头遍历.

3.获取

　　get(int index)

　　getFirst();

　　getLast();

　　E peek(): 获取头元素.不移除.

　　E peekFirst(); 同上

　　E peekLast(); 获取尾部元素,不删除.

分别是获取指定索引元素

获取头元素

获取尾元素.

4.删除

Boolean　　remove(int index);

E　　removeFrist();

boolean removeLastOcurrence(Object 0); 删除最后一次出现的指定元素.一般遍历去做.

E Set(int index,E element); 给一个索引.替换这个索引的对象. 并且返回替换索引的对象.

四丶总结:

　　　1.Collection接口是提供有序的接口

　　　 2. Set接口跟list接口分别实现了Collection接口.并且有不同的属性

　　　3.list接口增加了 E get(int index); 以及 E set(int index,Object o); 两个方法.

　　　4.迭代

　　　　　　迭代可以使用迭代类. Iterator. List接口实现的子类都有方法iterator返回迭代器

　　　　使用方法:

　

iterator<E> a = xxx.iterator();
while(a.hasNext()){

　　　E e = (e)a.next(); 必须使用next指向下一个元素.
}

　　　　　　如果是list可以使用 size() 配合get方法进行遍历

　　

for(int i = 0; i < a.size();i++){

  xxx a = (xxx)  a.get(i);  ;
}

　　5.ArrayList 类 以及 LinkedList类.

一个类是可变数组.Arraylist 一个是链表 LinkedList. 他们都有不同的方法.

但是如果是实现了List接口.那么共有的方法就是增删改查. 除非使用单独的类. 我们可以具体查询方法.