day20

.List集合遍历有几种方式
        
        四种:
            Collection的Iterator iterator()
            Collection的Object[] toArray() 
            size()+get(int index)--->普通for循环
            List专有的遍历方式:列表迭代器:ListIterator listIterator()
            
            foreach:增强for循环:JDK5以后的新特性,替代迭代器
            for(数据类型 变量名: 集合对象){
                    
            }
            

2.并发修改异常出现的原因以及解决方案?
        当使用迭代器遍历元素的时候,集合不能同时去操作这个元素;
        解决方案:
            1)迭代器遍历元素,迭代器去操作元素
            2)集合遍历元素,集合操作


3.List集合三个子实现类的特点
        ArrayList:底层数据结构是数组,查询快,增删慢
        线程不安全的类,不同步----->单线程中执行效率高(默认集合使用就是ArrayList)
        
        Vector:底层数据结构是可变的数组,查询快,增删慢
        线程安全的类---同步----->多线程中使用(安全性高),执行效率低!
        
        LinkedList:底层数据结构是链接列表(列表):查询慢,增删快
        线程不安全的类,不同步---->链表结构就默认使用LinkedList(效率高,安全性低)


4.Collection集合遍历方式
        
            Collection的Iterator iterator()
            Collection的Object[] toArray() 

5.static关键字的特点
        1)随着类的加载而加载
        2)优先于对象存在,不能和this共存
        3)最基本:能够被多个对象共用,共享
        4)访问方式:通过类名访问
            类名.变量名;
            类名.方法名();

6.final,finalize的区别
        final:状态修饰符(最终的,终态的)
         修饰类,类不能继承
         修饰方法,方法不能被重写
         修饰变量,此时变量是一个常量
         
         
         finalize它是一个方法;跟gc有关系,当内存没有更多对象引用的时候,需要开启GC,由Object的finalize()回收
这些对象,将被占用的空间给释放! 

         JDK5以后:增强for循环


 * 一般场景:
 *          遍历集合或者数组:遍历集合居多,增强for是为了简化迭代器的书写方式,替代集合的迭代器
 *
 *          集合中使用较为广泛
 *
 *     格式:
 *          for(集合中存储的数据类型 变量名 : 集合对象){
 *
 *              使用变量名
 *          }
 *
 *
 *        使用List集合来存储String类型/Student类型(自定义类型)
 *
 *
 *        注意事项:
 *              要使用增强for,前提条件就是集合不能为空

public class ForEachDemo {
    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<String>() ;

        //添加元素
        list.add("hello") ;
        list.add("world") ;
        list.add("java") ;

        //增强for----就是迭代器
        //需求:如果集合中有一个"world",给集合中添加一个javaee
       /* for(String s : list ){
            //获取到s
            if("world".equals(s)){
                list.add("javaee") ;
            }
        }*/

       //集合遍历,集合添加
       for(int x = 0 ; x < list.size() ;x ++){
           String s = list.get(x);
           if("world".equals(s)){
               list.add("javaee") ;
           }
       }
        System.out.println(list);

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

        //创建一个新的List集合对象
        List<Student> stuList = new ArrayList<Student>() ;

        //创建三个学生
        Student s1 = new Student("刘备",30) ;
        Student s2 = new Student("关羽",25) ;
        Student s3 = new Student("张飞",20) ;

        stuList.add(s1) ;
        stuList.add(s2) ;
        stuList.add(s3) ;


        stuList = null ;
        //要使用增强for,必须集合不能空,否则空指针异常
        if(stuList!=null){
            for(Student s : stuList){
                System.out.println(s.getName()+"---"+s.getAge());
            }
        }

    }
}

使用LinkedList来模拟栈结构特点:先进后出!

public class MyStack {

    private LinkedList link  = null ;

    //无参构造方法
    public MyStack(){
        link = new LinkedList() ;
    }

    //提供一个方法:每次调用这个方法的时候,将元素添加到开头
    public void add(Object obj){ //模拟栈:进栈的方式压栈
        link.addFirst(obj);
    }

    //提供一个方法:每次调用,获取元素,同时删除链表开头元素( 栈:出栈的方式叫弹栈)
    public Object get(){
        return link.removeFirst() ; //将列表的开头元素删除,返回被删除的元素!
    }

    //判断集合是否空
    public boolean isEmpty(){
        return link.isEmpty() ;//为空,则返回true/不为空,则返回false
    }

}

 线程安全的类
 *      StringBuffer:字符串缓冲区
 *      Vector集合(将元素都称为 "组件")
 *          特有功能
 *              public void addElement(Object obj):添加元素
 *              public Enumeration<E> elements():获取向量组件的枚举  (类似于 Iterator iterator())
 *                      Enumeration:
 *                              boolean hasMoreElements():判断是否有很多的元素---类似于:boolean hasNext()
 *                              Object nextElement():                       ---- 类似于:Object next()
 *
 *             public E elementAt(int index):-------类似于:List集合中的get(int index)
 *                      获取索引值对应的"组件"
 *                      和size()相结合----普通for循环的遍历方式
            

public class VectorDemo {
    public static void main(String[] args) {
        //创建一个Vector集合
        Vector<String> vector = new Vector<String>() ;

        //添加字符串元素,特有功能
        vector.addElement("hello");
        vector.addElement("world");
        vector.addElement("JavaEE");
      //  System.out.println(vector);

        //获取它的Enurmation: 向量组件的枚举
        Enumeration<String> enumeration = vector.elements();
        while(enumeration.hasMoreElements()){
            //获取
            String s = enumeration.nextElement();
            System.out.println(s);
        }

        System.out.println("----------------------------------");
        //普通for循环
        for(int x = 0 ; x < vector.size() ; x ++){
            String s = vector.elementAt(x);
            System.out.println(s);
        }
    }
}

List集合的获取功能(List集合的专有遍历方式):
 *
 *  ListIterator<E> listIterator()  :获取列表迭代器
 *
 *          ListIterator
 *                      正向遍历
 *                      boolean hasNext():判断是否有下一个可以迭代的元素
 *                      E next():获取下一个元素
 *
 *
 *                      逆向遍历
 *                      boolean  hasPrevious():判断是否有上一个可以迭代的元素
 *                      E previous():获取上一个元素
 *      先有正向遍历,才能逆向遍历

public class ListDemo {
    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<String>() ;

        //添加字符串元素
        list.add("hello") ;
        list.add("world") ;
        list.add("java") ;
        list.add("javaEE") ;

        //获取列表迭代器
        ListIterator<String> lit = list.listIterator();
       //遍历
        while(lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("-------------------------------");
        while(lit.hasPrevious()){
            String s = lit.previous() ;
            System.out.println(s);
        }

    }
}

 LinkedList特有功能:
 *      public void addFirst(E e):将元素添加到开头
 *      public void addLast(E e):将元素添加到链表的末尾
 *
 *      public   Object removeFirst():删除列表的第一个元素,并返回的是第一个元素
 *      public   Object removeLast():
 *
 *  获取
 *          public E getFirst():获取列表的开头元素
 *          public E getLast()

public class LinkedListDemo {

    public static void main(String[] args) {

        //创建LinkedList集合对象
        LinkedList<String> link = new LinkedList<String>() ;

        //添加
        link.addFirst("hello");
        link.addFirst("world");
        link.addFirst("javaEE");


//        public   Object removeFirst():

        /*System.out.println(link.removeFirst());
        System.out.println(link.removeFirst());*/
        System.out.println(link.getFirst());

        System.out.println(link);
    }

}

 Set集合和List集合区别
 *  List有序(存储和取出一致)
 *       允许元素重复
 *  Set无序(存储和取出不一致)
 *       不允许元素重复
 *
 *          Set接口不能实例化,最具体的子类:使用HashSet以及TreeSet
 *          HashSet(线程不安全的类:它允许null元素可以出现,执行效率高)----底层由HashMap实现


HashSet的add方法---依赖于HashMap的put方法
        依赖于:hash方法需要计算每一个元素的hash码值(hashCode())
        依赖equals方法:比较内容是否相同

public class HashSetDemo {
    public static void main(String[] args) {

        //创建Set集合对象
        Set<String> set = new HashSet<String>() ;

        System.out.println(set);

        //添加元素
        /*set.add(null) ;
        set.add("hello") ;
        set.add("hello") ;
        set.add("world") ;
        set.add("JavaEE") ;
        set.add("JavaEE") ;
        set.add("world") ;
        set.add("hello") ;*/
        set.add("hello") ;
        set.add("world") ;
        set.add("world") ;
        set.add("world") ;
        set.add("JavaEE") ;
        set.add("hello") ;
        set.add("hello") ;
        set.add("hello") ;

        System.out.println(set);

        //遍历
        for(String s : set){
            System.out.println(s);
        }



    }
}

            
             使用Set集合存储自定义对象并遍历,并且保证Student元素唯一的!
 *
 *  当使用set集合存储自定义对象,要保证元素唯一,
 *              就需要set集合底层依赖于hashCode和equals方法!
 *
 *              Set集合特点:它不保证遍历顺序恒久不变(哈希表决定的)

public class SetTest {

    public static void main(String[] args) {

        HashSet<Student> hashSet = new HashSet<Student>() ;

        //添加一些学生对象
        Student s1 = new Student("文章",35) ;
        Student s2 = new Student("文章",35) ;
        Student s3 = new Student("文章",30) ;
        Student s4 = new Student("高圆圆",41) ;
        Student s5 = new Student("高圆圆",41) ;
        Student s6 = new Student("吴奇隆",50) ;
        Student s7 = new Student("成龙",60) ;
        Student s8 = new Student("成龙",60) ;
        //添加到set集合
        hashSet.add(s1) ;
        hashSet.add(s2) ;
        hashSet.add(s3) ;
        hashSet.add(s4) ;
        hashSet.add(s5) ;
        hashSet.add(s6) ;
        hashSet.add(s7) ;
        hashSet.add(s8) ;

        //遍历
        for(Student s: hashSet){
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}
public class Student {

    private String name ;
    private int age ;

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }


    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

如果我们现在使用TreeSet集合存储自定义对象,并自然排序 应该注意什么?
 *
 *  存储自定义对象所在的类必须实现一个接口:Comparable接口:实现自然排序----->
 *
 *  必须要给定一个排序的主要条件!
 *              现在的主要条件:按照学生的年龄从小到大排序
 *
 *              次要条件:
 *                      学生年龄相同,比较姓名的内容是否相同
 *
 *  自然排序:执行无参构造方:TreeSet<E>()
 *
 *
 *  TreeSet集合:存储元素之后,按照某种规则排序输出! 而规则:题意明确给出"主要条件"

public class TreeSetDemo2 {
    public static void main(String[] args) {

        TreeSet<Student> ts = new TreeSet<Student>() ;//自然排序

        //创建学生对象
        Student s1 = new Student("gaoyuanyuan",41) ;
        Student s2 = new Student("gaoyuanyuan",35) ;
        Student s3 = new Student("gaoyuanyuan",35) ;
        Student s4 = new Student("liushishi",45) ;
        Student s5 = new Student("zhangsans",35) ;
        Student s6 = new Student("wenzhang",34) ;
        Student s7 = new Student("lisi",25) ;
        Student s8 = new Student("wenzhang",34) ;
        Student s9 = new Student("wawo",23) ;

        ts.add(s1) ;
        ts.add(s2) ;
        ts.add(s3) ;
        ts.add(s4) ;
        ts.add(s5) ;
        ts.add(s6) ;
        ts.add(s7) ;
        ts.add(s8) ;
        ts.add(s9) ;

        for(Student s : ts){
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
} 

//学生重写compareTo方法
public int compareTo(Student s) {
        //gaoyuanyuan,41 :根节点
       // 按照学生的年龄从小到大排序
       int num = s.age - this.age ;    //后面的元素和当前元素节点的元素进行比较

        //学生的年龄相同,不一定是同一个人(次要条件)
        int num2 = (num==0)? this.name.compareTo(s.name):num ;  //String类的compareTo():按照字典顺序比较
        //排序条件
        return num2 ;
    }
}
//:按照学生的姓名长度从小到大
 public int compareTo(Student s) {
        //主要条件:按照学生的姓名长度从小到大
        int num = this.name.length() - s.name.length() ;
        //次要条件:如果姓名长度相同,比较姓名的内容是否一样
        int num2 = (num==0)?this.name.compareTo(s.name):num ;

        //如果姓名长度相同,姓名内容也一样,比较年龄是否一样
        int num3 = (num2==0)? this.age-s.age : num2 ;
        return num3  ;
    }
}

Comparator接口的实现类
 *
 *
 *
 * TreeSet存储自定义对象有两种排序:
 *      自然排序---->自定义对象所在类必须实现一个接口:Comparable,重写接口中的compareTo(T t)
 *      比较器排序---->
 *           方式1:自定义一个类实现Comparator接口,重写接口中的compare(T o1,T o2)
 *           方式2:直接使用Comparator接口匿名内部类

public class MyCoparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        //s1---->this
        //s2---->s
        //按照学生的年龄从小到大排序
        int num = s1.getAge() - s2.getAge() ;
        /**
         * 自己分析 次要条件:
         *                        学生年龄相同,比较姓名的内容是否相同
         */
        int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;

        return num2;
    }
}
public class TreeDemo {

    public static void main(String[] args) {

        //public TreeSet(Comparator  comparator):有参构造方法
        //创建TreeSet集合对象TreeSet
        //方式1:定义Comparator比较器函数的接口的子实现类
//        MyCoparator myCoparator = new MyCoparator() ;
       // TreeSet<Student> ts = new TreeSet<Student>(myCoparator) ;

        //方式2:接口匿名内部类----本质就是当前Compartor接口的子实现类对象!
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>(){

            @Override
            public int compare(Student s1, Student s2) {
                //s1---->this
                //s2---->s
                //按照学生的年龄从小到大排序
                int num = s2.getAge() - s1.getAge() ;
                /**
                 * 自己分析 次要条件:
                 *                        学生年龄相同,比较姓名的内容是否相同
                 */
                int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;

                return num2;
            }
        }) ;

        //创建学生对象
        Student s1 = new Student("gaoyuanyuan",41) ;
        Student s2 = new Student("gaoyuanyuan",35) ;
        Student s3 = new Student("gaoyuanyuan",35) ;
        Student s4 = new Student("liushishi",45) ;
        Student s5 = new Student("zhangsans",35) ;
        Student s6 = new Student("wenzhang",34) ;
        Student s7 = new Student("lisi",25) ;
        Student s8 = new Student("wenzhang",34) ;
        Student s9 = new Student("wawo",23) ;

        ts.add(s1) ;
        ts.add(s2) ;
        ts.add(s3) ;
        ts.add(s4) ;
        ts.add(s5) ;
        ts.add(s6) ;
        ts.add(s7) ;
        ts.add(s8) ;
        ts.add(s9) ;

        for(Student s : ts){
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

.Set集合和List集合的区别?
        元素是否重复:
            Set:不允许重复(HashSet---依赖于HashMap(依赖于哈希表))
            List:允许元素重复
        元素存储是否有序
            Set:无序性,不能保证该顺序恒久不变
            List:有序,存储和取出是一致的
            
            还可以从子实现类区别去说
            

2.TreeSet集合存储自定义对象,什么情况下是自然排序
    什么情况下是比较器排序
    
    
要存储自定义对象,当前自定义对象所在的类必须实现Comparable接口 重写compareTo(T o)方法(自然排序)TreeSet的无参构造方法
                一些常用类中:Integer,String等等都实现 Comparable<T>
                
  比较器排序:有参构造方法:
        TreeSet(Comparator<? super E> com)
                        MyComparator my = new MyComparator() ;
        
        1)可以自定义一个类实现Comparator接口,重写compare(T t1,T t2)
        2)直接使用接口匿名内部类的方式来实现(推荐)
            

3.HashSet集合存储自定义对象如何保证元素唯一
            当前自定义对象所在类重写hashCode()和equals方法()

4.LinkedList集合的特有功能有哪些            
            addFirst()
            addLast()
            
            getFirst()
            getLast()
            
            removeFirst()
            removeLast()

5.什么是增强for循环,作用是什么?
        增强for:
                遍历集合使用的
                for(存储数据类型 变量名: 集合对象){
                    //使用变量名
                }
                
                替代 (迭代器使用的)

6.什么是泛型,泛型有什么好处
        <存储的数据类型:引用类型>
        
        泛型的好处:
            1)将运行时期提前到了编译时期----提高程序安全性
            2)避免了强制类型 转换    Iterator<E>  iterator();
            3)解决黄色警告线

模拟斗地主的洗牌和发牌

/*情况1:不考虑每个手上牌上有序
 *
 *
 * 步骤:
 *      1)创建一个牌盒            ----->使用集合: ArrayList<String>
 *      2)装牌
 *      3)洗牌
 *      4)发牌
 *      5)看牌
 *
 *
 *
 *      问题:每个手上的无序的,如何保证每个人手上的牌有序!
 */
public class PokerDemo {

    public static void main(String[] args) {

        //创建一个牌盒
        ArrayList<String> array = new ArrayList<String>() ;

        //装牌
        //创建点数数组
        String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"} ;
        //创建花色数组
        String[] colors = {"♥","♠","♣","♦"} ;
        for(String number:numbers ){
            for(String color:colors){
                //使用字符串的拼接功能
                String poker = color.concat(number);
                //将扑克装到arrayList集合中
                array.add(poker) ;
            }
        }
        //装大王,和小王
        array.add("小王") ;
        array.add("大王") ;
       // System.out.println(array);

        //洗牌:随机置换
        Collections.shuffle(array);
     //   System.out.println(array);

        //发牌
        //创建三个人
        ArrayList<String> player1 = new ArrayList<String>() ;
        ArrayList<String> player2 = new ArrayList<String>() ;
        ArrayList<String> player3 = new ArrayList<String>() ;
        ArrayList<String> diPai = new ArrayList<String>() ;
        //A,B,C  A--->B--->C
        //遍历array :牌盒中的牌
        for(int x = 0 ; x < array.size() ; x ++){
            //规律
            if(x>=array.size()-3){
                //底牌
                diPai.add(array.get(x)) ;
            }else if(x % 3 == 0){
                //玩家1
                player1.add(array.get(x)) ;
            }else if(x % 3 == 1){
                //玩家2
                player2.add(array.get(x)) ;
            }else if(x % 3 == 2){
                //玩家3
                player3.add(array.get(x)) ;
            }
        }


        //看牌:
        //三个都可以看牌,并且看底牌
        //可以将看牌封装成一个功能
        lookPoker("高圆圆",player1);
        lookPoker("赵又廷",player2);
        lookPoker("耿明刚",player3);
        lookPoker("底牌",diPai);
    }
    public static void lookPoker(String name,ArrayList<String> array){
        System.out.print(name+"都的牌是:");
        //遍历ArrayList
        for(String s: array){
            System.out.print(s+"\t");
        }
        System.out.println();

    }
}

       针对集合操作的工具类
 *
 *  public static <T extends Comparable<? super T>> void sort(List<T> list):针对List集合进行自然排序
 *  public static <T> void sort(List<T> list,Comparator<? super T> c):针对List集合进行比较器排序
 *  public static <T> int binarySearch(List<<? extends Comparable<? super T>>,  T key)
 *      集合中的二分搜索 :前提条件:当前集合中的元素必须有序的!
 *public static <T> void sort(List<T> list,
 *                             Comparator<? super T> c):对列表元素进行随机置换
 *  public static  T max(Collection<? extends T> coll)     :求最大值
 *  public static T min(Collection<? extends T> coll):求最小值

public class CollectionsDemo {

    public static void main(String[] args) {

        //创建List集合对象
        List<Integer> list = new ArrayList<Integer>() ;

        list.add(20) ;
        list.add(17) ;
        list.add(19) ;
        list.add(23) ;
        list.add(21) ;
        list.add(16) ;
        list.add(24) ;

        //public static <T extends Comparable<? super T>> void sort(List<T> list):针对List集合进行自然排序
        System.out.println(list);

        Collections.sort(list);
        System.out.println(list);

        //public static <T> int binarySearch(List<<? extends Comparable<? super T>>,  T key)
        int index = Collections.binarySearch(list,20) ;
        System.out.println(index);
        System.out.println("-------------------------------------");
        Collections.shuffle(list);  //随机置换
        System.out.println(list);
        System.out.println(Collections.max(list));
        System.out.println(Collections.min(list));


        //List<Student>:针对学生的年龄从小到大排序----->工具类:Collections.sort(list,new Comparator<Student>(){
        //          ...
        //
        // }) ;




    }
}

public class PokerTest {

    public static void main(String[] args) {
        //创建一个牌盒
        HashMap<Integer,String> hm  = new HashMap<Integer, String>() ;
        //创建一个ArrayList:单独存储编号
        ArrayList<Integer> array = new ArrayList<Integer>() ;

        //编号是从0开始
        int index = 0 ;
        //装牌
        //花色数组
        //点数数组
        String[] colors = {"♥","♠","♣","♦"} ;
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"} ;
        for(String number: numbers){
            for (String color:colors){
                String poker = number.concat(color);
                //装到HashMap集合中
                hm.put(index,poker) ;
                //将编号ArrayList集合中
                array.add(index) ;
                index ++ ;
            }
        }

        //装小王和大王
        hm.put(index,"小王") ;
        array.add(index) ;
        index ++ ;
        hm.put(index,"大王") ;
        array.add(index) ;

       // System.out.println(array);

        //洗牌洗的编号
        Collections.shuffle(array);
       // System.out.println(array);


        //发牌:为了保证每一个牌是有序,使用TreeSet集合<Integer>:发的也是编号
        TreeSet<Integer> player1 = new TreeSet<Integer>() ;
        TreeSet<Integer> player2 = new TreeSet<Integer>() ;
        TreeSet<Integer> player3 = new TreeSet<Integer>() ;
        TreeSet<Integer> diPai = new TreeSet<Integer>() ;

        //发牌
        for(int x = 0 ; x < array.size() ; x ++){
            if(x>=array.size()-3){
                diPai.add(array.get(x)) ;
            }else if(x % 3 ==0 ){
                //玩家1
                player1.add(array.get(x)) ;
            }else if(x % 3 == 1){
                //玩家2
                player2.add(array.get(x)) ;
            }else if(x % 3 == 2){
                //玩家3
                player3.add(array.get(x)) ;
            }
        }

        //看牌: 封装一个功能
        lookPoker("杨德财",hm,player1) ;
        lookPoker("王思宇",hm,player2) ;
        lookPoker("耿明刚",hm,player3) ;
        lookPoker("底牌",hm,diPai) ;

    }

    //看牌的功能
    public static void lookPoker(String name, HashMap<Integer,String> hashMap,
                                 TreeSet<Integer> ts){
        System.out.print(name+"的牌是:");
        //遍历TreeSet集合---获取到每一个编号
        for(Integer key: ts){
            //在通过编号获取值: hashMap在这里去找
            String value = hashMap.get(key);
            System.out.print(value+"\t");
        }
        System.out.println();
    }
}

  Java提供了一个集合Map<K,V>:K 就是键  V :就是值
 *  *          Integer    String
 *  *           1            张三
 *  *
 *  *           2             李四
 *  *
 *  *           3             王五
 *  *           ...           ...
 *  *
 *  *     一个键对应一个值
 *  *  Map集合和Collection集合的区别?
 *  *  Collection:单例集合:只能存储一种类型(引用类型)
 *  *          Set集合和Map集合有一定的间接关系
 *  *              HashSet<E>的添加功能add依赖Map里面的HashMap<K,V>的put方法
 *                 TreeSet<E>的add方法依赖于Map里面TreeMap<K,V>的put方法
 *
 *
 *  *
 *  *  Map:双列集合,可以存储键和值:两种类型
 *          存储的一系列的键值对元素   Map集合:针对键有效,跟值无关,键必须唯一的!
 *                          默认的使用HashMap:允许元素出现null键和null值,线程不安全的类!
 *
 *
 *   Map集合的功能:
 *          添加
 *              V put(K key,V value) :添加一个键值对元素
 *
 *               注意事项: 细节:返回什么意思?
 *              如果键是第一次添加,那么返回是null
 *              如果键不是第一次添加,后面添加键对应的值将第一次的值覆盖掉,将第一次的值返回!
 *
 *          删除
 *                  void clear()
 *                  V remove(Object key):删除指定的键,返回被删除键对应的值
 *          判断
 *                  boolean containsKey(Object key):判断是否包含指定的键
 *                  boolean containsValue(Object value):判断是否包含指定的值
 *          获取
 *
 *               Collection<V> values():获取Map集合中的所有的值的集合
 *
 *
 *              方式1:Map的遍历
 *              Set<K> keySet():获取Map集合的中的所有的键
 *              V get(Object key):然后在通过键获取值
 *
 *              //方式2:Map的遍历
 *               Set<Map.Entry<K,V>> entrySet():获取键值对对象

//HashMap:底层数据结构:哈希表:键必须唯一的!存储和取出无序
public class HashMapDemo {
    public static void main(String[] args) {

        //创建一个Map集合对象
        Map<String,String> map = new HashMap<String,String>() ;
       // System.out.println(map);

        //V put(K key,V value) :添加一个键值对元素
        String value = map.put("文章", "马伊琍");
        System.out.println(value);
        String value2 = map.put("文章", "姚笛");
        System.out.println(value2);

      /*  map.put("黄晓明","babay") ;
        map.put("邓超","孙俪") ;
        map.put("高圆圆","赵又廷") ;
        map.put("向佐","郭碧婷") ;*/
        System.out.println(map);

        // void clear()
        // *                  V remove(Object key):删除指定的键,返回被删除键对应的值
       // map.clear();
      //  System.out.println(map.remove("邓超"));
      //  System.out.println(map);
        /*
        * boolean containsKey(Object key):判断是否包含指定的键
         *                  boolean containsValue(Object value):判断是否包含指定的值
        * */
        /*System.out.println(map.containsKey("周杰伦"));
        System.out.println(map.containsKey("黄晓明"));
        System.out.println(map.containsValue("孙俪"));

        //  Collection<V> values():获取Map集合中的所有的值的集合
        Collection<String> values = map.values() ;
        for(String s:values){
            System.out.println(s);
        }*/

    }
}

public class HashMapDemo2 {

    public static void main(String[] args) {

        //遍历操作
        // 方式1:Map的遍历(夫妻对)  :推荐 第一种方式(常用的)
        //      Set<K> keySet():获取Map集合的中的所有的键   (获取所有的丈夫所在的集合)
        //             V get(Object key):然后在通过键获取值  (通过丈夫找妻子)
        //创建HashMap集合对象
        HashMap<String,String> hm = new HashMap<String,String>() ;

        //添加元素
        hm.put("杨过","小龙女") ;
        hm.put("郭靖","黄蓉") ;
        hm.put("陈玄风","梅超风") ;
        hm.put("令狐冲","任盈盈") ;

        //遍历:
        Set<String> keySet = hm.keySet();
        for(String key :keySet){
            //在键获取值
            //V get(Object key)
            String value = hm.get(key);
            System.out.println(key+"="+value);
        }

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

        //方式2:Map的遍历(结婚证)
       //Set<Map.Entry<K,V>> entrySet():获取键值对对象
        //通过结婚证--->获取丈夫和妻子
        //K getKey()
        //V getValue()
        Set<Map.Entry<String, String>> entrySet = hm.entrySet();
        for(Map.Entry<String,String> entry:entrySet ){
            //分别获取键和值
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }


    }
}

TreeMap:红黑树结构:进行元素排序
 *  自然排序:TreeMap<K,V>()
 *  比较器排序:TreeMap<K,V>(Comparator com)
 *
 *
 *  需求: 键:自定义类型
 *      使用TreeMap存储学生K:Student(name,age)   姓名---"给英文字母"
 *                         V:爱好:String类型
 *
 *
 *           主要条件: 按照学生的年龄从小到大排序   (自然排序,比较器排序)
 *
 *           使用keySet()遍历---通过键获取值

一个班级的学生使用ArrayList<Student>
 *    很多个班级:ArrayList<ArrayList<Student>>
 *
 *      创建三个班级,将三个班级的学生添加大的集合中,遍历大的集合

public class ArrayListTest {

    public static void main(String[] args) {

        //创建一个大的集合对象
        ArrayList<ArrayList<Student>>  bigArray = new ArrayList<ArrayList<Student>>() ;

        //第一个班级:
        ArrayList<Student> array1 = new ArrayList<Student>() ;
        //添加学生
        Student s1 = new Student("盲僧",30) ;
        Student s2 = new Student("亚索",25) ;
        Student s3 = new Student("奥巴马",20) ;
        array1.add(s1) ;
        array1.add(s2) ;
        array1.add(s3) ;
        //添加到到的集合中
        bigArray.add(array1) ;

        //第二个班级
        ArrayList<Student> array2 = new ArrayList<Student>() ;
        //添加学生
        Student s4 = new Student("刘备",30) ;
        Student s5 = new Student("关羽",25) ;
        Student s6 = new Student("张飞",20) ;
        array2.add(s4) ;
        array2.add(s5) ;
        array2.add(s6) ;
        bigArray.add(array2) ;


        //第三个班级
        ArrayList<Student> array3 = new ArrayList<Student>() ;
        //添加学生
        Student s7 = new Student("唐僧",30) ;
        Student s8 = new Student("孙悟空",25) ;
        Student s9 = new Student("猪八戒",20) ;
        array3.add(s7) ;
        array3.add(s8) ;
        array3.add(s9) ;
        bigArray.add(array3) ;

        //遍历大的集合 ArrayList<ArrayList<Student>>
        for(ArrayList<Student> array : bigArray){
            for(Student s : array){
                System.out.println(s.getName()+"\t"+s.getAge());
            }
        }


    }
}

              

上一篇:每日一题-Day20-判断链表是否为回文结构


下一篇:day20.线程2