list接口、set接口、map接口、异常

List接口：存取有序、可以重复、有索引可用

 list方法：add（） add(index,e) get(index) remove(index) remove() set(index,e) 可以操作下标

list存储数据的结构

堆栈：先进后出

队列：先进先出

数组：查找快，增删慢

链表：增删块，查找慢

ArrayList:数组结构

LinkedList:链表结构，有大量的首尾操作方法 

Vector集合：被ArrayList集合代替

public static void method(){
        LinkedList<String> l = new LinkedList<String>();
//        l.addFirst("a");
//        l.addFirst("b");
//        l.addFirst("c");
        l.addLast("a");
        l.addLast("b");
        l.addLast("c");
            System.out.println(l.removeFirst());
            System.out.println(l.removeFirst());
            System.out.println(l.removeFirst());    
    }

set集合

HashSet集合不能存放重复元素，因为有hashcode方法和equals方法

public static void method3(){
        HashSet<Person> set = new HashSet<Person>();
        set.add(new Person("a",20));
        set.add(new Person("b",10));
        set.add(new Person("c",30));
        set.add(new Person("c",30));
        System.out.println(set);
    }

利用hashset不能存放重复元素的特性，统计一段话中每个字符出现的次数

public static void method2(){
        String str ="If~you-want~to~change-your_fate_I_think~you~must~come-to-the-dark-horse-to-learn-java";
        char[] chars = str.toCharArray();
        HashSet<Character> set = new HashSet<Character>();
        for(char c:chars){
            set.add(c);
        }
             int m = 0;
            for(Character c:set){
                for(int i = 0;i<str.length();i++){
                    if(c.equals(str.charAt(i))){
                        m++;
                    }
                }
                System.out.print("("+c+")"+m);
                m=0;
            }    
    }

为了保证顺序的话，可以用linkedhashset

LinkedHashSet：存进去的元素不能重复，有顺序

public static void method4(){
        LinkedHashSet<String> set = new LinkedHashSet<String>();
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

map接口：

 双列集合   键不能重复   值可以重复

hashmap：哈希表结构   无序 不能重复

linkedhashmap：哈希表结构+链表结构   有序   不能重复

get（）方法通过键获得值   put（）方法放入键和值   remove（）方法通过键移除键值对

keyset（）方法：用来遍历

public static void method1(){
        Map<String,String> map = new HashMap<String,String>();
        map.put("黄晓明","baby");
        map.put("邓超","孙俪");
        map.put("李晨","范冰冰");
        map.remove("李晨");
        System.out.println(map.get("李晨"));
    }

public static void method2(){
        Map<String,String> map = new HashMap<String,String>();
        map.put("黄晓明","baby");
        map.put("邓超","孙俪");
        map.put("李晨","范冰冰");
        map.put("徐峥","陶虹");
        Set<String> s = map.keySet(); 
        Iterator<String> it = s.iterator();
        while(it.hasNext()){
            System.out.println(map.get(it.next()));
        }
    }

entryset（）方法：用来遍历

返回一个set集合，里面是键值对（entry）对象

entry接口：map接口中提供的一个静态内部嵌套接口 直接用map.entry（）调用

entry接口中的方法：getkey（）返回entry对象中的键   getvalue（）返回键对应的值

public static void method5(){
      HashMap<String,HashMap<Integer,String>> map = new HashMap<String,HashMap<Integer,String>>();
        HashMap<Integer,String> class1= new HashMap<Integer,String>();
        HashMap<Integer,String> class2= new HashMap<Integer,String>();
        class1.put(1,"董斌");
        class1.put(2,"张禄");
        class2.put(1,"田雨");
        class2.put(2,"李宝林");
        map.put("java0328",class1);
        map.put("java0131",class2);
        //Entry
        //for遍历
        Set<Map.Entry<String,HashMap<Integer,String>>> oset = map.entrySet();
//        for(Map.Entry<String,HashMap<Integer,String>> m:oset){
//            String str = m.getKey();
//            HashMap<Integer,String> hm = m.getValue();
//            Set<Map.Entry<Integer,String>> hmm = hm.entrySet();
//            for(Map.Entry<Integer,String> hma:hmm){
//               int ii = hma.getKey();
//               String name = hma.getValue();
//               System.out.println(str+"..."+ii+"..."+name);
//            }
//        }

map中存放自定义类的对象，为了保证不能重复，要重写自定义类中的hashcode方法和equals方法

静态导入：代码的简写

public static void method(){
        out.println("静态导入");
        int[] arr ={1,6,9,22,33};
        sort(arr);
        for(int i:arr){
            out.print(i+" ");
        }
    }

可变参数：JDK1.5之后才有，定义一个方法时，如果需要传多个参数，且参数类型一致，可以使用，不用传数组，把数组中的元素直接穿进去就可以，在编译成class文件时，系统自动把这些实参放在数组里，只是在1.5之后简化了这个操作

格式：修饰符   返回值   方法名（参数类型...形参名）{}

等价于：修饰符   返回值   方法名（参数类型[]   形参名）{}，只是次定义方式只能传数组，而可变参数可以直接传数据

public static double add(double...a){
        //计算两个数的和
        double sum = 0;
        for(double i:a){
            sum+=i;
        }
        return sum;
    }

collections：集合工具类，操作集合

shuffle（）方法   随机重置顺序

sort（）方法   升序

斗地主发牌：

首先，要用map来进行操作，对牌从大到小排序，实际上是对键的排序，

因为collections中的sort（）方法是升序，所以最大的牌对应的键应该是最小的

因为一副牌同一个值有四个花色，所以在用两个循环把牌和花色整理的过程中，应该是

外层控制牌，内层控制循环

然后，我们对牌进行洗牌的操作，其实是对一个和map中键一样的集合进行shuffle（）随机重置

发牌的过程也是发的这个重置后的集合，有几个人就对及取余

public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashMap<Integer,String> pooker = new HashMap<Integer,String>();
        ArrayList<Integer> pookerNumber = new ArrayList<Integer>();
        String[] color = {"♥","♦","♠","♣"};
        String[] number = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        int index = 2;
        for(String num:number){
            for(String c:color){
                pooker.put(index,c+num);
                pookerNumber.add(index);
                index++;
            }
        }
        pooker.put(0,"大王");
        pookerNumber.add(0);
        pooker.put(1,"小王");
        pookerNumber.add(1);
        Collections.shuffle(pookerNumber);
        ArrayList<Integer> player1 = new ArrayList<Integer>();
        ArrayList<Integer> player2 = new ArrayList<Integer>();
        ArrayList<Integer> player3 = new ArrayList<Integer>();
        ArrayList<Integer> bottom = new ArrayList<Integer>();
        for(int i = 0;i<pookerNumber.size();i++){
            if(i<3){
                bottom.add(pookerNumber.get(i));
            }else if(i%3==0){
                player1.add(pookerNumber.get(i));
            }else if(i%3==1){
                player2.add(pookerNumber.get(i));
            }else if(i%3==2){
                player3.add(pookerNumber.get(i));
            }
        }
        Collections.sort(player1);
        Collections.sort(player2);
        Collections.sort(player3);
        Collections.sort(bottom);
        look("玩家一",player1,pooker);
        look("玩家二",player2,pooker);
        look("玩家三",player3,pooker);
        look("底牌",bottom,pooker);
    }
    public static void look(String name,ArrayList<Integer> player,HashMap<Integer,String> pooker){
        for(Integer s:player){
            System.out.print(pooker.get(s));
        }
        System.out.println();
    }

异常：java代码编译 运行期间发生的某种异常

错误：java运行期间发生的发生的错误

异常的继承体系：throwable超类 下面有error和exception两个子类 

throw：在方法内 抛出异常 后面需要接一个异常类的对象

throws：在方法参数列表后 声明异常 后面接异常类

 try catch finally：捕获处理异常

有多个catch时，子类异常必须在父类异常的上面

runtimexception：运行时期异常   只需抛出，无需声明，也不需要处理，需要需改代码，类似于error

子类重写父类方法时，声明的异常必须小于等于父类方法中声明的异常，在父类方法没有声明异常时，只能用try catch finally 处理

异常方法：

printStackTrace（）：在控制台输出异常名称、详细信息、异常出现的代码位置

toString（）：返回一个字符串，包括异常名称、详细信息

getMessage（）：返回一个字符串，详细信息

自定义异常：

一定要继承exception或exception的子类，在构造方法中要用super调用父类的无参构造和有参构造

继承exception类的话，必须用throws声明

继承runtimeexception类，无需throws声明，也不用处理