集合框架2

本章概述：

一、Iterator的使用

1、IteratorDemo

二、LinkedList的使用

1、LinkedListDemo

2、ListDemo

3、Vector的使用

三、Set的使用

1、SetDemo

本章概述：
一、Iterator的使用
1、IteratorDemo
package collection.class2;
 
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
 

 
/*
 * 在java代码中包含三种循环的方式
 *   do...while
 *   while
 *   for
 * 还有一种增强for循环的方式，可以简化循环的编写
 *
 *
 *   所有的集合类都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，也就是for-each
 *      增强for循环本质上使用的也是iterator的功能
 *      方法：
 *               iterator()
 *               foreach()
 *   在iterator的方法中，要求返回一个Iterator的接口子类实例对象
 *       此接口中包含了
 *               hasNext()
 *               next()
 *
 *   在使用iterator进行迭代的过程中如果删除其中的某个元素会报错，并发操作异常，因此
 *       如果遍历的同时需要修改元素，建议使用listIterator（），
 *   ListIterator迭代器提供了向前和向后两种遍历的方式
 *       始终是通过cursor和lastRet的指针来获取元素值及向下的遍历索引
 *       当使用向前遍历的时候必须要保证指针在迭代器的结果，否则无法获取结果值
 * */
public class IteratorDemo {
 
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add("123");
        list.add(true);
        list.add(100L);
        list.add(10.0d);
        //遍历集合
//        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
 
        System.out.println("*******************");
        //使用迭代器
//        Iterator iterator = list.iterator();
        ListIterator listIterator = list.listIterator();
        while(listIterator.hasNext()){
//            if(list.contains("123")){  并发操作异常
//                list.remove("123");
//            }
//            Object o = listIterator.next();
//            if("123".equals(o)){
//                listIterator.remove();
//            }
            System.out.println(listIterator.next());
        }
//        System.out.println(list);
 
//        System.out.println("*******************");
//        //增强for循环
//        for(Object i :list){
//            System.out.println(i);
//        }
        System.out.println("*********************************");
        while(listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
 
    }
}
二、LinkedList的使用
1、LinkedListDemo
package collection.class2;
 
import java.util.LinkedList;
 

 
/*
 * linkedList拥有更加丰富的方法实现，需要用的时候查询api即可，不需要记忆
 *
 * */
public class LinkedListDemo {
 
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(1);
        list.add("abc");
        list.add(true);
        list.add("abc");
        list.add(100L);
        System.out.println(list);
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        list.addFirst("ok");
        System.out.println(list);
//        System.out.println(list.peek());
//        System.out.println(list);
//        System.out.println(list.poll());
//        System.out.println(list);
//        System.out.println(list.pop());
//        System.out.println(list);
        list.push("no");
        System.out.println(list);
 
 
 
 
    }
}
2、ListDemo
package collection.class2;
 
import java.util.ArrayList;
import java.util.List;
 

 
/*
 * java集合框架：
 *   List：存放的是单一值
 *       特点：
 *           1、可以存放不同类型的数据，而数组只能存放固定类型的数据
 *           2、当使用Arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作
 *       api方法：
 *           增加数据的方法
 *           add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程
 *           addAll:添加另一个集合的元素到此集合中
 *
 *           删除数据的方法
 *           clear:只是清空集合中的元素，但是此集合对象并没有被回收
 *           remove:删除指定元素
 *           removeAll：删除集合元素
 *
 *           查询数据的方法
 *           contains:判断集合中是否包含指定的元素值
 *           containsAll:判断此集合中是否包含另一个集合
 *           isEmpty:判断集合是否等于空
 *           retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
 *           size:返回当前集合的大小
 *
 *           //集合转数组的操作
 *           toArray:将集合转换成数组
 * */
 
public class ListDemo {
 
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(123);
        list.add("abc");
        list.add(18.0);
        list.add(true);
        list.add(18.0);
        System.out.println(list);
        list.add(0,"ok");
        System.out.println(list);
        Object o = list.get(0);
        System.out.println(o);
        System.out.println(list.indexOf(18.0));
        System.out.println(list.lastIndexOf(18.0));
        System.out.println(list.size());
//        list.remove(1);
//        System.out.println(list);
        list.set(4,false);
        System.out.println(list);
        System.out.println(list.subList(1,4));
 
 
    }
}
3、Vector的使用
package collection.class2;
 
import java.util.Vector;
 

 
/**
 *      1、Vector也是List接口的一个子类实现
 *      2、Vector跟ArrayList一样，底层都是使用数组进行实现的
 *      3、面试经常问区别：
 *              1) ArrayList是非线程安全的，高效率，Vector是线程安全的，低效率
 *              2）ArrayList扩容的时候每次扩容1.5倍，Vector扩容的时候每次扩容2倍
 *
 * */
 
public class VectorDemo {
 
    public static void main(String[] args) {
        Vector vector =new Vector();
        vector.add(123);
        vector.add("123");
        vector.add(true);
        vector.add(100L);
        System.out.println(vector);
        System.out.println(vector.firstElement());
    }
}
三、Set的使用
1、SetDemo
package collection.class2;
 
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
 

 
/*
 *   1、set中存放的是无序，唯一的数据
 *   2、set不可以通过下标获取对应位置的元素的值，因为无序的特点
 *   3、使用Treeset底层的实现是Treemap,利用红黑树来进行实现
 *   4、设置元素的时候，如果是自定义对象，会查找对象中的equals和hashcode的方法，如果没有，比较的是地址
 *   5、树中的元素是要默认进行排序操作的，如果是基本数据类型，自动比较，如果是引用类型的话，需要自定义比较器
 *       比较器分类：
 *         内部比较器
 *               定义在元素的类中，通过实现Comparable接口来进行实现
 *         外部比较器
 *               定义在当前类中，通过实现Comparator接口来实现，但是要将该比较器传递到集合中
 *         注意：外部比较器可以定义成一个工具类，此时所有需要比较的规则如果一致的话，可以复用，而
 *               内部比较器只有在存储当前对象的时候才可以使用
 *               如果两者同时存在，使用外部比较器
 *               当使用比较器的时候，不会调用equals方法
 * */
public class SetDemo implements Comparator {
 
    public static void main(String[] args) {
//        Set set = new HashSet();
//        set.add(1);
//        set.add("abc");
//        set.add(true);
//        set.add(100L);
//        set.add("abc");
//        System.out.println(set);
 
        //遍历集合
//        for (int i = 0; i < set.size(); i++) {
//            System.out.println(set.get);
//        }
 
        //迭代器遍历
//        Iterator iterator = set.iterator();
//        while(iterator.hasNext()){
//            Object obj = iterator.next();
//            System.out.println(obj);
//        }
 
        //增强for循环
//        for(Object o : set){
//            System.out.println(o);
//        }
 
//        System.out.println("*******************************");
//        for(Iterator iterator1 = set.iterator();iterator1.hasNext();){
//            System.out.println(iterator1.next());
//        }
 
//        Set set = new TreeSet();
//        set.add(1);
//        set.add(123);
//        set.add(5);
//        set.add(20);
//        set.add("abc");
//        set.add("casd");
//        set.add("dasd");
//        set.add("bfh");
//        System.out.println(set);
 
        Set set = new TreeSet(new SetDemo());
        set.add(new Person("zhangfei",19));
        set.add(new Person("guanyu",20));
        set.add(new Person("zhaoyun",18));
        set.add(new Person("mashaladi",30));
        System.out.println(set);
    }
 
    @Override
    public int compare(Object o1, Object o2) {
        Person p1 = (Person)o1;
        Person p2 = (Person)o2;
        if(p1.getAge() > p2.getAge()){
            return -1;
        }else if(p1.getAge() < p2.getAge()){
            return 1;
        }else{
            return 0;
        }
    }
}