day20

最新推荐文章于 2022-04-27 16:03:16 发布

Pershings

最新推荐文章于 2022-04-27 16:03:16 发布

阅读量84

点赞数

本文链接：https://blog.csdn.net/Pershinggeng/article/details/117385347

版权

.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());
            }
        }


    }
}

Pershings

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day20

.List集合遍历有几种方式四种: Collection的Iterator iterator() Collection的Object[] toArray() size()+get(int index)--->普通for循环 List专有的遍历方式:列表迭代器:ListIterator listIterator() for...
复制链接

扫一扫