Java day15

集合

1. 概述
   集合是对象类型的数组
   是为了解决数组的长度无法改变的问题,而出现
2. 集合和数组的区别
   共同点:
   都是存储数据的容器
   不同点:
   1. 存储内容不同:
      数组可以存储基本数据类型,也可以存储引用数据类型
      集合只能存储引用数据类型,如果需要存储基本数据类型,存储的是包装类对象
   2. 存储数量不同
      数组长度不可变,一旦确定大小就不可改变
      集合长度可变
   3. 方法不同
      数组只有Object中定义的方法,和一个length属性
      集合有很多的方法
3. 集合的体系结构
   1. 单列集合:
      1. collection
         1. List
            ArrayList
            LinkedList
            Vector
      2. Set
         HashSet
         TreeSet
   2. 双列集合:
      1. Map
         HashMap
         TreeMap

collection

1. 概述
   单列集合的顶层接口
   因为是一个接口,所以不能实例化
   可以声明一个Collection的变量,指向其子类的对象
2. 常用方法
   add(Object object):添加元素
   remove(Object object):删除元素
   clear():清空集合
   isEmpty():判断是否为空
   contains(Object object):判断是否包含object
   size():返回元素个数

//创建一个News类,用来存储信息
public class News {
    public String title;
    public String msg;
    public Date date;

    public News() {
    }

    public News(String title, String msg, Date date) {
        this.title = title;
        this.msg = msg;
        this.date = date;
    }

    @Override
    public String toString() {
        return "News{" +
                "title='" + title + '\'' +
                ", msg='" + msg + '\'' +
                ", date=" + new SimpleDateFormat("yyyy-MM-dd").format(date) +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Collection col = new ArrayList(); //创建一个Collection类的变量
        News news1 =  new News("No1","News01",new Date(1000000000000L));
        News news2 =  new News("No2","News02",new Date(2000000000000L));
        News news3 =  new News("No3","News03",new Date(3000000000000L));

        col.add(news1); //添加元素
        col.add(news2);
        col.add(news3);

        Iterator iter = col.iterator(); //得到迭代器,进行遍历输出
        while(iter.hasNext()){
            System.out.println(iter.next()); 
        }

        if(!(col.isEmpty())){ //判断集合是否为空
            for(Object obj:col.toArray()){ //集合转换成数组
                System.out.println(obj);
            }
        }

        col.remove(news3); //删除元素

        if(!(col.isEmpty())){
            for(Object obj:col.toArray()){
                System.out.println(obj);
            }
        }
    }
}

List

1. 概述:
   Collection的一个子接口
   同样不可以实例化
   特点是:有序,有索引,元素可重复
2. 特有方法
   add(int index,Object object):在指定索引处添加元素
   remove(int index):删除指定索引的元素
   set(int index,Object object):修改指定索引的元素
   get(int index):获取指定索引的元素

public class Test {
    public static void main(String[] args) {
        List list = new ArrayList(); //创建List

        News news1 =  new News("No1","News01",new Date(1000000000000L));
        News news2 =  new News("No2","News02",new Date(2000000000000L));
        News news3 =  new News("No3","News03",new Date(3000000000000L));

        list.add(news1); //添加元素
        list.add(news2);
        list.add(news3);

        System.out.println("======================");
		
		//一种遍历方式
        Object[] objects = list.toArray(); //list转换成数组
        for(int i=0;i<list.size();i++){
            System.out.println(objects[i]);
        }

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

		//第二种遍历方式
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i)); //通过索引遍历
        }

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

		//第三种遍历方式
        for(Object obj:list){
            System.out.println(obj); //通过增强for循环遍历
        }

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

		//第四种遍历方式
        Iterator iterator = list.iterator(); //通过迭代器遍历
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

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


    }
}

ArrayList

1. 概述:
   是List的一个实现类
   数组实现,顺序存储,线程不安全
   查询速度较快

LinkedList

1. 概述:
   是List的一个实现类
   链表实现,顺序存储,线程不安全
   增删速度较快
2. 特有方法:
   addFrist(Object object):添加元素至开始
   addLast(Object object):添加元素至结尾
   removeFrist():删除开始元素
   removeLast():删除结尾元素
   getFrist():获取开始元素
   getLast():获取结尾元素

public class Test {
    public static void main(String[] args) {
        String str = "ha li ha ha ha li ni";
        String[] s = str.split(" +");
        LinkedList list = new LinkedList();
        list.addFirst(s[0]); //添加至开始
        list.addLast(s[s.length-1]); //添加至结尾
        for(int i=1,j=1;i<s.length-1;i++){
            if(!(s[i].equals("li"))){
                list.add(j,s[i]);
                j++;
            }
        }
        System.out.println(list);
    }
}

Vector

1. 概述:
   是List的一个实现类
   数组实现,顺序存储,线程安全
2. 特有方法
   addElement(Object object):添加元素
   removeElement(Object object):删除元素
   elements();获取集合的迭代对象,用于遍历

//比较ArrayList,LinkedList,Vector的插入和查询性能
public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        
        test.arrayList();
        //ArrayList insert:10
		//ArrayList get:0
		
        test.linkedList();
        //LinkedList insert:2
		//LinkedList get:86
		
        test.vector();
		//Vector insert:9
		//Vector get:1


    }

    public void arrayList(){
        ArrayList list = new ArrayList();

        long start = System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            list.add(0,i);
        }
        long end = System.currentTimeMillis();

        long start1 = System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            list.get(5000);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("ArrayList insert:"+(end-start));
        System.out.println("ArrayList get:"+(end1-start1));
    }

    public void linkedList(){
        LinkedList list = new LinkedList();

        long start = System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            list.addFirst(i);
        }
        long end = System.currentTimeMillis();

        long start1 = System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            list.get(5000);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("LinkedList insert:"+(end-start));
        System.out.println("LinkedList get:"+(end1-start1));
    }

    public void vector(){
        Vector list = new Vector();

        long start = System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            list.add(0,i);
        }
        long end = System.currentTimeMillis();

        long start1 = System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            list.get(5000);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("Vector insert:"+(end-start));
        System.out.println("Vector get:"+(end1-start1));
    }
}