android不可重复的list 不允许重复的list

Collection集合中比较常用的有两大种，一是Set集合（不可重复），二是List（可重复）集合，本篇文章来介绍List集合的具体使用。

一、List集合概述和特点
（1）概述
① 有序集合（也称为序列），用户可以精确的控制列表中的每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素。
② 与Set集合不同，列表通常允许重复的元素。
（2）特点
① 有序：存储和取出的元素顺序一致。
② 可重复：存储的元素可以重复。

/*
* List集合，又称序列，可重复。有循序
* 遍历也是继承Collection
* 使用迭代器即可
* */
public class ListTest {
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();//多态创建list对象
        list.add("Tom");//创建并添加对象
        list.add("Jim");
        list.add("Mike");
//        System.out.println(list);
        Iterator<String> itr = list.iterator();
        while (itr.hasNext()){
            System.out.println(itr.next());
        }
    }
}

二、List集合的特有方法

import java.util.ArrayList;
import java.util.List;

/*
* List集合特有方法练习
* 1.add(int index,E element)在此集合的指定位置插入制定的元素（对象）
* 2.remove(int index) 删除指定索引处的元素，并返回删除的元素
* 3.set(int index,E element) 修改索引处的元素，返回被标记的元素
* 4.get(int index) 返回指定索引处的元素
* */
public class ListPrivateTest {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();//创建List集合对象
        list.add("Tom");//添加元素
        list.add("Jim");
        list.add("Mike");
        //1.add方法
        list.add(0,"sTom");
//        System.out.println(list);
        //2.remove方法
        list.remove(0);
       // System.out.println(list);
        //3.set方法
        list.set(0,"sTom");
       // System.out.println(list);
        //4.get方法
        System.out.println(list.get(0));
    }
}

三、List并发异常处理

List并发修改异常产生的原因是，通过迭代器遍历的过程中，通过集合添加元素，会造成Iterator中预期修改集合的次数和实际修改集合的次数不一致。从而产生了并发修改异常。

可以通过使用for循环，使用List的get方法获得对象进行操作。

四、ListIterator列表迭代器

通过List集合的ListIterator（）方法得到，是List结合特有的迭代器。

其对List最强大的支持是可以在遍历中使用add方法直接添加list对象（这很重要，因为Iterator会产生给你并发修改异常错误！）。

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/*
* ListIterator列表迭代器
* 相对于Iterator，其对List有更强的支持
* E next()、boolean hasNext（）对象创建方法都是一样的
* 其最强大的支持是可以在遍历中使用add方法直接添加list对象（这很重要，因为Iterator会产生给你并发修改异常错误！）。
* 还具有
* E pervious（）返回上一个对象
* boolean haspervious()若上一个存在元素返回true,结合使用可逆行遍历
* add(E e)添加指定元素到List中
*
* */
public class ListIteratorTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Tom");
        list.add("Jim");
        list.add("Mike");
        //创建ListIterator对象
        ListIterator listIterator = list.listIterator();
        //1.E pervious（）方法
        //System.out.println(listIterator.previous());
        //2.boolean hasPrevious()方法
        //System.out.println(listIterator.hasPrevious());
        //3.add(E e)
//        listIterator.add("tom");
//        System.out.println("正---向---遍----历");
//        while (listIterator.hasNext()){
//            System.out.println(listIterator.next());
//        }
//        //System.out.println(listIterator);
//        System.out.println("逆---向---遍----历");
//        while (listIterator.hasPrevious()){
//            System.out.println(listIterator.previous());
//        }
        //
            while (listIterator.hasNext()){ 
                String str = (String) listIterator.next();
                if(str.equals("Mike")){
                listIterator.add("tom");
            }
               //在这里直接使用ListIterator的add方法不会产生并发修改异常
               //而Iterator的没有add方法，使用list的add方法便会产生这个异常
               //所以在Iterator添加遍历添加对象时都不使用hasNext和next
       }
//        for(int i = 0;i<list.size();i++){//Iterator不能遍历添加对象，只能使用这种方式
//            String str = list.get(i);
//            if(str.equals("Mike")){
//                list.add("tom");
//            }
//        }

        System.out.println(list);

    }
}

五、增强for循环
目的：简化数组和Collection集合的遍历。其内部原理就是一个Iterator迭代器。

import java.util.ArrayList;
import java.util.Collection;
/*
* for each是jdk5之后出现的
* 方便数组和Collection集合的遍历
* 其原理就是底层Iterator
* */
public class ForEachTest {
    public static void main(String[] args) {
          /*
    * 1.Array[] 对数组的遍历
    * */
//        int[] arr = {0,3,1,21};
//        for(int i: arr){
//            System.out.println(i);
//        }
        //2.Collection集合
        Collection<Integer> collection = new ArrayList<Integer>();
        collection.add(1);
        collection.add(12);
        collection.add(13);
        for (int i: collection) {
            System.out.println(i);
        }
    }
}

六、常见的数据结构

（1）数组

数组是一种查询快、增删慢的模型。

（2）链表

相对于数组，链表是一种增删快、查询慢的模型