• 集合1--毕向东java基础教程视频学习笔记


    Day14 集合框架
    01 体系概述
    02 共性方法
    03 迭代器
    04 List集合共性方法
    05 ListIterator
    06 List集合具体对象特点
    07 Vector中的枚举

     

    01 体系概述

    集合类
    为什么出现集合类?
    面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就需要对对象进行存储。
    集合就是存储对象最常用的一种方式。

    数组和集合类同是容器,有何不同?
    数组虽然也可以存储对象,但长度是固定的,集合的长度是可变的。
    数组中可以存储进本数据类型,集合只能存储对象。
    集合类的特点:
    集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。


    02 共性方法

    1.add方法的参数是object类型,以便与接受任意类型对象。
    2.集合中存储的都是对象的引用(地址)。

     1 import java.util.*;
     2 class  CollectionDemo
     3 {
     4     public static void main(String[] args) 
     5     {
     6         method();
     7         base_Method();
     8         
     9 
    10     }
    11     //求交集
    12     public static void method()
    13     {
    14         ArrayList al=new ArrayList();
    15         al.add("java01");
    16         al.add("java02");
    17         al.add("java03");
    18         al.add("java04");
    19         sop("al原集合"+al);
    20 
    21         ArrayList al2=new ArrayList();
    22         al2.add("java01");
    23         al2.add("java07");
    24         al2.add("java03");
    25         al2.add("java08");
    26         sop("al2原集合"+al2);
    27 
    28         al.retainAll(al2);
    29         sop("al求交后的集合"+al);
    30 
    31 
    32     }
    33     public static void base_Method()
    34     {
    35         //创建一个集合容器,使用Collection接口的子类,ArrayList
    36         ArrayList al=new ArrayList();
    37         
    38 
    39         //1.添加元素
    40         al.add("java01");
    41         al.add("java02");
    42         al.add("java03");
    43         al.add("java04");
    44 
    45         //打印集合
    46         sop("原集合:"+al);
    47         //2.删除元素
    48         al.remove("java02");
    49         sop("改变后的集合:"+al);
    50         //al.clear();
    51 
    52         //4.判断元素
    53         sop("java03是否存在"+al.contains("java03"));
    54         sop("集合是否为空"+al.isEmpty());
    55 
    56         //获取集合长度
    57         sop("size:"+al.size());
    58     }
    59     public static void sop(Object obj)
    60     {
    61         System.out.println(obj);
    62     }
    63 }
    View Code

     

    03 迭代器

    什么是迭代器?
    其实就是集合中取出元素的方式。

    把取出方式定义在集合的内部。
    这样取出方式就可以直接访问集合内部的元素。
    那么取出方式被定义为内部类。
    每一个容器的数据结构不同,
    取出的动作细节不一样,但都有共性的内容
    判断和取出,那么可以将共性抽取。

    这些内部类都符合一个规则。该规则是Iterator.
    如何获取集合的取出对象呢?
    通过一个对外提供的方法
    iterator();

     1 import java.util.*;
     2 class  CollectionDemo
     3 {
     4     public static void main(String[] args) 
     5     {
     6         method();
     7 
     8     }
     9     //求交集
    10     public static void method()
    11     {
    12         ArrayList al=new ArrayList();
    13         al.add("java01");
    14         al.add("java02");
    15         al.add("java03");
    16         al.add("java04");
    17         
    18         //获取迭代器,用于取出集合中的元素
    19         /*Iterator it=al.iterator();
    20 
    21         while(it.hasNext())
    22         {
    23             sop(it.next());
    24         }
    25         */
    26         for(Iterator it=al.iterator();it.hasNext();)
    27         {
    28             sop(it.next());
    29         }
    30 
    31     }
    32 
    33     public static void sop(Object obj)
    34     {
    35         System.out.println(obj);
    36     }
    37 }
    View Code

     


    04 List集合共性方法

    Collection
    |--List:元素是有序的,元素可以重复。因为该集合有索引。
    |--Set:元素是无序的,元素不可以重复。

    List:
    凡是可以操作角标的方法都是该体系的特有方法

    增:add(index,element)
    addAll(index,Collection)

    删:remove(index)

    改:set(index,element)

    查:get(index)
    subList(from,to)
    listIterator();

     1 import java.util.*;
     2 class ListDemo 
     3 {
     4     public static void sop(Object obj)
     5     {
     6         System.out.println(obj);
     7     }
     8     public static void main(String[] args) 
     9     {
    10         ArrayList al=new ArrayList();
    11         al.add("java01");
    12         al.add("java02");
    13         al.add("java03");
    14         sop("原集合:"+al);
    15 
    16         //在指定位置添加元素
    17         al.add(1,"java09");
    18         sop("改变后集合:"+al);
    19 
    20         //删除指定位置的元素
    21         //al.remove(2);
    22 
    23         //修改元素
    24         al.set(2,"java07");
    25         //sop(al);
    26 
    27         //通过角标获取元素
    28         sop("get(i)"+al.get(1));
    29 
    30         //获取所有元素
    31         for(int x=0;x<al.size();x++)
    32         {
    33             System.out.println("al("+x+")="+al.get(x));
    34         }
    35 
    36         
    37         for(Iterator it=al.iterator();it.hasNext();)
    38         {
    39             sop("next:"+it.next());
    40         }
    41 
    42     }
    43 }
    View Code

     

    05 ListIterator

    List集合特有的迭代器:ListIterator是Iterator的子接口。
    在迭代时,不可以通过集合的方法操作集合中的元素。
    因为会发生ConcurrentModificationException异常。

    所以,在迭代时,只能用迭代器的方法操作元素,可是iterator方法是有限的
    只能对元素进行判断,取出,删除
    如果想要做其他的操作,如添加、修改等,就需要用到其子接口ListIterator

    该接口只能通过List的ListIterator方法获取。

     1 import java.util.*;
     2 class ListDemo 
     3 {
     4     public static void sop(Object obj)
     5     {
     6         System.out.println(obj);
     7     }
     8     public static void main(String[] args) 
     9     {
    10         ArrayList al=new ArrayList();
    11         al.add("java01");
    12         al.add("java02");
    13         al.add("java03");
    14         sop("原集合:"+al);
    15 
    16         ListIterator li=al.listIterator();
    17         //在迭代过程中,操作元素
    18         while(li.hasNext())
    19         {
    20             Object obj=li.next();
    21             if(obj.equals("java02"))
    22                 li.set("java006");
    23         }
    24         sop("改变后集合:"+al);
    25 
    26         //逆序输出
    27         while(li.hasPrevious())
    28         {
    29             sop("pre:"+li.previous());
    30 
    31         }
    32         sop(al);
    33 
    34     }
    35 }
    View Code

     


    06 List集合具体对象特点

    |--List:元素是有序的,元素可以重复。因为该集合有索引。
      |--ArrayList:底层的数据结构使用的数组结构。特点:查询速度很快,但是增删稍慢,元素越多,这点体现越明显。线程不同步。
      |--LinkedList:底层使用的是链表数据结构。 特点:增删快,查询速度很慢。
      |--Vector:底层是数组数据结构。它比ArrayList先出现。 线程同步。被ArrayList代替了。


    07 Vector中的枚举

     1 /*
     2 枚举就是Vector特有的取出方式。
     3 发现枚举和迭代器很像。
     4 其实枚举和迭代是一样的。
     5 
     6 因为枚举的名称以及方法的名称都过长。
     7 所以被迭代器取代了。
     8 枚举郁郁而终。
     9 */
    10 import java.util.*;
    11 
    12 class VectorDemo 
    13 {
    14     public static void main(String[] args) 
    15     {
    16         Vector v=new Vector();
    17         
    18         v.add("java01");
    19         v.add("java02");
    20         v.add("java03");
    21         v.add("java04");
    22 
    23         Enumeration en=v.elements();
    24 
    25         while(en.hasMoreElements())
    26         {
    27             System.out.println(en.nextElement());
    28         }
    29 
    30     }
    31 }

     

  • 相关阅读:
    js封装日期格式化函数
    原生js时间戳获取和转换
    自适应好用的一个css
    ES6五种遍历对象属性的方式
    ES6对象属性名简洁表示法和表达式、对象新方法、属性的遍历
    ES6数组扩展运算符(Rest+Spread)、类方法、原型方法
    正则表达式常见匹配
    typescript深copy和浅copy
    判断一个变量类型是对象还是数组
    npm 淘宝镜像的配置
  • 原文地址:https://www.cnblogs.com/wsw-tcsygrwfqd/p/5146788.html
Copyright © 2020-2023  润新知