JAVA--018集合框架

List

import com.lovo.bean.Student;

public class TestList {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * List:线性。
         * 元素在集合中的存放是有位置下标的。
         * 放置的顺序就是存储的顺序，可以通过下标进行访问
         */
        //1、首先产生容器对象
        //ArrayList--在底层使用的是数组作为容器
        //使用环境：当需要大量的通过下标查找元素；往末尾添加和删除元素；
//      List al = new ArrayList();
        //LinkedList--在底层使用的是双向链表作为容器
        //使用环境：当需要大量往中间添加或删除元素
        List al = new LinkedList();
        //2、增：调用add方法，放入元素
        al.add("string");
        al.add(10);
        al.add(new Student("zhang3",18));
        al.add(new Date());
        //3、查：调用get方法，取出元素
        System.out.println(al.get(2));
        //4、改：修改元素
        al.set(0, "hellokitty");
        System.out.println(al.get(0));
        //5、删：删除元素
        al.remove(0);
        System.out.println(al.get(0));
        //6、获取集合的元素个数
        System.out.println(al.size());

        //7、遍历List
        //7-1、普通循环
        //可以通过对循环控制变量i进行改变，从而自由操作每个元素。
        //可以改变元素对象
        for(int i = 0; i < al.size(); i++){
            if(i == 0){
                al.set(0, 12);
            }
            System.out.println(al.get(i));
        }
        System.out.println("====================");
        //7-2、for-each循环---JDK1.5以后
        //只能从头到尾操作一遍
        //不能改变元素对象,一旦赋值就指向新的对象，而集合里面没有变
        for(Object obj : al){
            System.out.println(obj);
        }
        System.out.println("=====================");
        //7-3、迭代器-----JDK1.5以前
        //只能从头到尾操作一遍
        //不能改变元素对象,一旦赋值就指向新的对象，而集合里面没有变
        Iterator it = al.iterator();
        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }


        //8、泛型--限制容器只能存放某种数据类型的元素或是子类元素
        List<Student> lst = new ArrayList<Student>();
        lst.add(new Student("liu6",22));

        //ArrayList\LinkedList\Vector做比较
    }

}

set

package com.lovo.test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import com.lovo.bean.Student;

public class TestSet {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * Set:不能重复
         * 元素在集合中的存储顺序与放入的顺序无关
         * 没有下标可言---Set集合没有办法操作指定的某个元素
         * 判断重复元素的标准：根据equals方法与hashCode方法
         */
        //1、产生容器对象
        Set set = new HashSet();
        //2、增：调用add方法添加元素
        set.add(new Student("zhang3",18));
        set.add("li4");
        set.add(26);
        set.add(new Student("zhang3",18));
        //2、删除：调用remove方法
//      set.remove(new Student("zhang3",18));
        //3、获取容器元素个数
        System.out.println(set.size());

        //4、遍历
        for(Object obj : set){
            System.out.println(obj);
        }
        System.out.println("===========================");
        Iterator it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        //5、支持泛型
        Set<Student> stuSet = new HashSet<Student>();
        stuSet.add(new Student());
    }

}

Map

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import com.lovo.bean.Student;


public class TestMap {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * Map:键值对(K-V)
         * 元素在集合中的存储顺序与放入的顺序无关
         * 通过键查找值
         * 键必须唯一(用equals方法和hashCode方法共同判断)，但值是可以重复的
         */
        //1、产生容器对象
        Map map = new HashMap();

        //2、增：调用put方法
        map.put("123", new Student());
        map.put(123, new Date());
        map.put(new Student("wang5",33), 80);

        //3、删除：调用remove方法
        map.remove(new Student("wang5",33));

        //4、查：调用get方法，通过键查找值(如果键不存在，得到null)
        System.out.println(map.get(123));

        //5、改：仍然调用put方法，传入相同的键，即为修改
        map.put("123", new Student("zhao6",28));

        //6、size方法获取元素个数
        System.out.println(map.size());

        //7、遍历：不能针对键值对同时遍历；要么遍历所有的键，要么遍历所有的值
        Set keySet = map.keySet();//得到所有的键
        Collection valueCol = map.values();//得到所有的值

        //由于Set和Collection都不具有线性
        //所以无论是键还是值都不能使用普通for循环进行遍历
        for(Object key : keySet){
            System.out.println(key);
        }
        System.out.println("=======================================");
        Iterator it = valueCol.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }


        //HashMap、Hashtable做比较
        //HashMap 能够使用null做键和做值，做键只能做一次（键不能重复）。线程不安全，效率高。
        //Hashtable 不能使用null做键和做值。线程安全，效率低。

    }

}

Collections–算法类

List<Integer> lst = new ArrayList<Integer>();
        lst.add(23);
        lst.add(213);
        lst.add(232);
        lst.add(123);
        lst.add(231);
        lst.add(21);

        Integer max = Collections.max(lst);
        Integer min = Collections.min(lst);
//      System.out.println(min);

        //排序只能针对于List
        List<String> strLst = new LinkedList<String>();
        strLst.add("hello");
        strLst.add("he");
        strLst.add("hell");
        strLst.add("helloworld");
        strLst.add("hellokitty");

        List<Student> stuLst = new ArrayList<Student>();
        stuLst.add(new Student("zhang3",18,78));
        stuLst.add(new Student("li4",22,89));
        stuLst.add(new Student("wang5",17,67));
        stuLst.add(new Student("zhao6",28,54));
        stuLst.add(new Student("chen7",23,72));

//      Collections.sort(stuLst);//按照自然顺序进行排序，自定义类型要给出该排序规则
        //当内外部比较器同时存在时，调用下面的方法将按外部比较器排序
        Collections.sort(stuLst, new StudentComparator());
//      Collections.reverse(strLst);//反转
//      Collections.shuffle(strLst);//混排--洗牌程序可以使用
        for(Student in : stuLst){
            System.out.println(in);
        }

Comparable 内部比较器

类中定义 后重写方法，实现内部比较

Comparator 外部比较器 接口