zoukankan      html  css  js  c++  java
  • JAVA基础-集合

    一、集合框架

    集合是用于存储对象的容器,集合可以进行扩容,集合的长度可变。

    下面是在网上找的一个图片,java集合框架图:

     

      上述类图中,实线边框的是实现类,如ArrayList,Vector,LinkedList,HashMap,TreeSet等,折线边框的是抽象类,比如AbstractCollection,AbstractList,AbstractMap等,而点线边框的是接口,比如Collection,Iterator,List等。

    集合类中三个最主要的接口List、Set、Map。 由上图可看出所有的类都实现了Iterator接口,Iterator接口是用于遍历集合内元素的接口。

    List接口主要的实现类ArrayList,LinkedList。

    Set接口主要实现类HashSet,TreeSet。

    Map接口主要实现类HashMap,TreeMap。

    二、           List实现类

    List集合特点:集合的元素是有序的,取出元素时支持先进先出,集合中的元素允许重复。

    2.1.ArrayList

    ArrayList集合底层结构是数组结构,由于底层结构是数组结构,所以访问速度极快。

    ArrayList中常用的方法。

    增:

    boolean  add(E e):将指定元素加入集合尾部

    void add(int index,E element):将指定元素加入集合指定位置

    boolean addAll(Collention <? Extends E> c): 按照指定 collection 的迭代器所返回的元素顺序,将该 collection 中的所有元素添加到集合的尾部。

    boolean addAll(int index,Collention <? Extends E> c): 按照指定 collection 的迭代器所返回的元素顺序,将该 collection 中的所有元素添加到集合指定位置。

    删:

    E remove(int index):将指定位置的元素删除,并且返回该元素。

    boolean remove(Object o):删除第一次出现的元素o,如果集合里有。

    void clear():删除集合中所有的元素

    改:

    set(int index,E e):将指定位置的元素更换为指定元素

        查:

          E get(int index):获得指定位置的元素。

          int size():获取集合的长度

          boolean isEmpty():判断集合是否为空

          boolean contains(Object o):判断结合中是否包含某个元素

          int IndexOf(Object o):判断第一次出现o元素的位置。如果没有返回-1

    下面使用代码进行演示:

      1 package Blogs;
      2 
      3  
      4 
      5 import java.util.ArrayList;
      6 
      7 import java.util.Iterator;
      8 
      9  
     10 
     11 public class ArrayListDemo {
     12 
     13  
     14 
     15     public static void main(String[] args) {
     16 
     17        // TODO Auto-generated method stub
     18 
     19        //建立ArrayList集合,并指定集合中的元素类型为String类型。
     20 
     21        ArrayList<String> al=new ArrayList<String>();
     22 
     23       
     24 
     25        //向集合中添加元素
     26 
     27        al.add("黑马");
     28 
     29        al.add("程序员");
     30 
     31        al.add("训练营");
     32 
     33        al.add("!");
     34 
     35        al.add("安卓");
     36 
     37        al.add("就业班");
     38 
     39        al.add("!!");
     40 
     41       
     42 
     43        //获得集合迭代器,将集合中内容迭代打印到控制台
     44 
     45        Iterator it=al.iterator();
     46 
     47        while(it.hasNext()){
     48 
     49            System.out.print(it.next());
     50 
     51        }
     52 
     53        System.out.println("");
     54 
     55       
     56 
     57        //获得集合长度
     58 
     59        System.out.println(al.size()); 
     60 
     61       
     62 
     63        //删除指定位置元素
     64 
     65        System.out.println("删除集合角标为1的元素:"+al.remove(1));
     66 
     67       
     68 
     69        //删除指定元素
     70 
     71        System.out.println("删除元素中的 安卓 :"+al.remove("安卓"));   
     72 
     73       
     74 
     75        //将指定位置元素更改为指定元素  
     76 
     77        al.set(3,"基础班");
     78 
     79        Iterator it1=al.iterator();
     80 
     81        while(it1.hasNext()){
     82 
     83            System.out.print(it1.next());
     84 
     85        }
     86 
     87        System.out.println("");
     88 
     89        //清空元素
     90 
     91        al.clear();
     92 
     93        //判断元素是否为空
     94 
     95        System.out.print("元素是否为空:"+al.isEmpty()); 
     96 
     97     }
     98 
     99  
    100 
    101 }
    View Code

     

    2.2LinkedList

    LinkedList集合底层采用链表结构存储数据,适用于频繁的增删元素。

     

    LinkedList常用方法:

    增:

    boolean  add(E e):将指定元素加入集合尾部

    void add(int index,E element):将指定元素加入集合指定位置

    boolean addAll(Collention <? Extends E> c): 按照指定 collection 的迭代器所返回的元素顺序,将该 collection 中的所有元素添加到集合的尾部。

    boolean addAll(int index,Collention <? Extends E> c): 按照指定 collection 的迭代器所返回的元素顺序,将该 collection 中的所有元素添加到集合指定位置。

    void addFrist(E e):将指定元素加到集合开头

    void addLast(E e):将指定元素加到集合结尾,和add(E e)等同

    删:

    E remove(int index):将指定位置的元素删除,并且返回该元素。

    boolean remove(Object o):删除第一次出现的元素o,如果集合里有。

    E removeFirst():获取并删除集合中第一个元素,当集合为空时,会抛出NoSuchElementException异常

    E removeLast():获取并删除集合中最后一个元素,当集合为空时,会抛出NoSuchElementException异常

    E pollFirst():获取并删除集合中第一个元素,当集合为空时,返回null;

    E pollLast():获取并删除集合中最后一个元素,当集合为空时,返回null;

    void clear():删除集合中所有的元素

    改:

    set(int index,E e):将指定位置的元素更换为指定元素

    查:

          E get(int index):获得指定位置的元素。

          int size():获取集合的长度

          boolean isEmpty():判断集合是否为空

          boolean contains(Object o):判断结合中是否包含某个元素

          int IndexOf(Object o):判断第一次出现o元素的位置。如果没有返回-1

      E getFrist():获取集合中第一个元素,当元素为空时,会抛出NoSuchElementException 异常

      E getLast():获取集合中最后一个元素,当元素为空时,会抛出NoSuchElementException 异常

      E peekFrist():获取集合中第一个元素,当元素为空时,返回null

      E peekLast():获取集合中最后一个元素,当元素为空时,返回null

    方法中主要增加头尾元素的操作,下面使用代码进行演示:

     1 package Blogs;
     2 
     3  
     4 
     5 import java.util.LinkedList;
     6 
     7 import java.util.ListIterator;
     8 
     9  
    10 
    11 public class LinkedListDemo {
    12 
    13     public static void main(String[] args){
    14 
    15        LinkedList<String>  ll=new LinkedList<String> ();
    16 
    17        //向集合中增加元素
    18 
    19        ll.add("黑马");
    20 
    21        ll.add("程序员");
    22 
    23        ll.add("训练营");
    24 
    25        //向集合头部增加元素
    26 
    27        ll.addFirst("itheima.com");
    28 
    29        //使用ListIterator迭代器,取出集合元素
    30 
    31        ListIterator<String> it=ll.listIterator();
    32 
    33        while(it.hasNext()){
    34 
    35            System.out.print(it.next());
    36 
    37        }
    38 
    39        System.out.println("");
    40 
    41        //获取集合中第一个元素
    42 
    43        System.out.println("集合中第一个元素为:"+ll.peekFirst());
    44 
    45        //删除第一个元素
    46 
    47        ll.pollFirst();
    48 
    49        System.out.println("删除第一个元素后、集合中第一个元素变为:"+ll.peekFirst());
    50 
    51        //清空集合中元素
    52 
    53        ll.clear();
    54 
    55        //使用peek(),获取空集合中的元素,返回为空
    56 
    57        System.out.print("集合内容为空时,使用peek进行获取元素:"+ll.peek());
    58 
    59     }
    60 
    61 }
    62 
    63  
    LinkedList

    输出结果如下:

    黑马程序员训练营!安卓就业班!!

    7

    删除集合角标为1的元素:程序员

    删除元素中的 安卓 :true

    黑马训练营!基础班!!

    元素是否为空:true

    三、     Set实现类

    set类中存放的是数据,是不允许重复的。

    3.1 HashSet

    HashSet类使用哈希表进行数据存储,判断是两个元素是否相同,是通过hashCode和equals两个方法进行判断,为了使HashSet集合中成功的存储元素,元素对应的类必须实现hashCode和equals方法。

    HashSet在对元素进行存储时,首先将需要存储的元素和已经存入的元素的哈希值进行比较,如果包含哈希值相同的元素,会再使用equals方法判断,如果返回true,则是为同一元素。

    代码示例:

      1 package Blogs;
      2 
      3  
      4 
      5 import java.util.HashSet;
      6 
      7 import java.util.Iterator;
      8 
      9  
     10 
     11 public class HashSetDemo {
     12 
     13  
     14 
     15     public static void main(String[] args) {
     16 
     17        // TODO Auto-generated method stub
     18 
     19        //建立HashSet集合对象
     20 
     21        HashSet<Student> hs=new HashSet<Student>();
     22 
     23        //对象中添加元素
     24 
     25        hs.add(new Student("张三",23));
     26 
     27        hs.add(new Student("李四",21));
     28 
     29        hs.add(new Student("王五",20));
     30 
     31        hs.add(new Student("张三",23));//此时写入失败
     32 
     33        hs.add(new Student("李四",22));
     34 
     35        //建立迭代器,将集合内容进行打印。
     36 
     37        Iterator<Student> it=hs.iterator();
     38 
     39        while(it.hasNext()){
     40 
     41            Student s=it.next();
     42 
     43            System.out.println(s.getname()+"--"+s.getage());
     44 
     45        }
     46 
     47     }
     48 
     49  
     50 
     51 }
     52 
     53 class Student{
     54 
     55     private String name;
     56 
     57     private int age;
     58 
     59     Student(String name,int age){
     60 
     61        this.name=name;
     62 
     63        this.age=age;
     64 
     65     }
     66 
     67     public String getname() {
     68 
     69        return name;
     70 
     71     }
     72 
     73     public int getage() {
     74 
     75        return age;
     76 
     77     }
     78 
     79     public int hashCode(){
     80 
     81        //复写hashCode方法
     82 
     83        return name.hashCode()+age*54;
     84 
     85       
     86 
     87     }
     88 
     89     public boolean equals(Object o){
     90 
     91        //复写equals方法
     92 
     93        if(!(o instanceof Student))
     94 
     95            return false;
     96 
     97        Student s=(Student)o;
     98 
     99        if(s.name.equals(name)&&s.age==age)
    100 
    101            return true;
    102 
    103        return false;
    104 
    105     }
    106 
    107 }
    HashSetDemo

    打印结果:

    李四--21

    张三--23

    李四--22

    王五—20

    由打印结果可看出,重复的元素并未写入,并且读取的内容是无序的。

    3.2TreeSet

    TreeSet集合中是按照“二叉树”方法存放元素,使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的 Comparator 进行排序。

     TreeSet存入的自定义类元素必须要实现Comparable接口或在创建集合时传入Comparator比较器进行排序。

    下面分别用两种方式对TreeSet内集合进行排序。

      1 package Blogs;
      2 
      3  
      4 
      5 import java.util.Comparator;
      6 
      7 import java.util.Iterator;
      8 
      9 import java.util.TreeSet;
     10 
     11  
     12 
     13 public class TreeSetDemo {
     14 
     15  
     16 
     17     public static void main(String[] args) {
     18 
     19        // TODO Auto-generated method stub
     20 
     21       
     22 
     23        System.out.println("按照年龄进行排序");
     24 
     25        //以Person自然排序规则进行排序(按照年龄排序)
     26 
     27        TreeSet<Person> ts=new TreeSet<Person>();
     28 
     29        ts.add(new Person("张三",32));
     30 
     31        ts.add(new Person("李四",33));
     32 
     33        ts.add(new Person("王五",31));
     34 
     35        ts.add(new Person("李四",30));
     36 
     37        ts.add(new Person("博士",32));
     38 
     39        Iterator<Person> it=ts.iterator();
     40 
     41        while(it.hasNext()){
     42 
     43            Person p=it.next();
     44 
     45            System.out.println(p.getname()+"--"+p.getage());
     46 
     47        }
     48 
     49  
     50 
     51        System.out.println("------------------------------------------");
     52 
     53        System.out.println("按照姓名进行排序");
     54 
     55        //传入比较器,按照比较器进行排序。(按照姓名排序)
     56 
     57        TreeSet<Person> ts1=new TreeSet<Person>(new myPersonCompare());
     58 
     59        ts1.add(new Person("张三",32));
     60 
     61        ts1.add(new Person("李四",33));
     62 
     63        ts1.add(new Person("王五",31));
     64 
     65        ts1.add(new Person("李四",30));
     66 
     67         ts1.add(new Person("博士",32));
     68 
     69        Iterator<Person> it1=ts1.iterator();
     70 
     71        while(it1.hasNext()){
     72 
     73            Person p=it1.next();
     74 
     75            System.out.println(p.getname()+"--"+p.getage());
     76 
     77        }
     78 
     79     }
     80 
     81 }
     82 
     83 //person类实现Comparable接口,以便使自己有排序规则
     84 
     85 class Person implements Comparable<Person>{
     86 
     87     private String name;
     88 
     89     private int age;
     90 
     91     Person(String name,int age){
     92 
     93        this.name=name;
     94 
     95        this.age=age;    
     96 
     97     }
     98 
     99     public String getname(){
    100 
    101        return name;
    102 
    103     }
    104 
    105     public int getage(){
    106 
    107        return age;
    108 
    109     }
    110 
    111     @Override
    112 
    113     //实现 compareTo 方法 按照年龄排序
    114 
    115     public int compareTo(Person o) {
    116 
    117        // TODO Auto-generated method stub
    118 
    119        Person p=(Person)o;
    120 
    121        if(this.age!=p.age)
    122 
    123            return this.age-p.age;
    124 
    125        else
    126 
    127            return this.name.compareTo(p.name);
    128 
    129     }
    130 
    131 }
    132 
    133  
    134 
    135 //定义比较器
    136 
    137 class myPersonCompare implements Comparator<Person>{
    138 
    139  
    140 
    141     @Override
    142 
    143     public int compare(Person p1, Person p2) {
    144 
    145        // TODO Auto-generated method stub
    146 
    147  
    148 
    149        if(p1.getname().equals(p2.getname()))
    150 
    151            return p1.getage()-p2.getage();
    152 
    153        else
    154 
    155            return p1.getname().compareTo(p2.getname());
    156 
    157     }
    158 
    159 }
    TreeSetDemo

    输出结果如下:

    按照年龄进行排序

    李四--30

    王五--31

    博士--32

    张三--32

    李四--33

    -------------------------------------------

    按照姓名进行排序

    博士--32

    张三--32

    李四--30

    李四--33

    王五--31

    四、            Map类

    Map类中存放的元素都是以键—值对进行存储的。其中的“键”必须是唯一的,值可以相同。

    4.1HashMap

    HashMap类常用的方法

    增:

    V put(K key,V value):在此映射中关联指定值与指定键,并返回键关联的旧值

    void putAll(Map<? extends K,? extends V> m):将指定映射的所有映射关系复制到此映射中,如果原来键对应的有值则替换原来的值。

    删:

    void clear():清除所有映射关系

    V remove(Object key):移除指定键的映射关系,并返回该键对应的值

    查:

    V get(Object key):获得指定键所映射的值,如果没有映射则返回null。

    int size():返回此映射中,映射关系数

    Collection<V> values():返回此映射中值得collection视图

    Set<Map.Entry<K,V>> entrySet():返回此映射所包含的映射关系的 Set 视图。

    判断:

    boolean containsKey(Object key):判断此映射中是否包含指定键

    boolean containsValue(Object value):判断此映射中是否包含指定值

    示例代码:

     1 package Blogs;
     2 
     3  
     4 
     5 import java.util.HashMap;
     6 
     7 import java.util.Map;
     8 
     9 import java.util.Set;
    10 
    11  
    12 
    13 public class MapDemo {
    14 
    15  
    16 
    17     public static void main(String[] args) {
    18 
    19        // TODO Auto-generated method stub
    20 
    21        //建立HashMap对象
    22 
    23        HashMap<String,Integer> hm=new HashMap<String,Integer>();
    24 
    25        //添加映射关系
    26 
    27        hm.put("张三", 24);
    28 
    29        hm.put("李四", 23);
    30 
    31        hm.put("王五", 25);
    32 
    33        //添加相同键的映射关系,会替换原来键对应的值
    34 
    35        hm.put("张三", 25);
    36 
    37        System.out.println("hm中的键值对为:"+hm);
    38 
    39  
    40 
    41        //判断是否有值“25”
    42 
    43        System.out.println("判断此映射中是否包含值25:"+hm.containsValue(25));
    44 
    45        //判断是否有键"赵六"
    46 
    47        System.out.println("判断此映射中是否有键 赵六:"+hm.containsKey("赵六"));
    48 
    49        //获取Set对象,使用entrySet()方法输出HashMap中的键值对
    50 
    51        Set<Map.Entry<String,Integer>> s=hm.entrySet();
    52 
    53        for(Map.Entry<String, Integer> m:s){
    54 
    55            System.out.println(m.getKey()+"-----"+m.getValue());
    56 
    57        }
    58 
    59       
    60 
    61        System.out.println("使用keySet方法获取键值对");
    62 
    63        Set<String> s1=hm.keySet();
    64 
    65        for(String sr:s1){
    66 
    67            System.out.println("键:"+sr+"---值:"+hm.get(sr));
    68 
    69        }
    70 
    71     }
    72 
    73 }
    HashMapDemo

    输出结果:

    hm中的键值对为:{李四=23, 张三=25, 王五=25}

    判断此映射中是否包含值25:true

    判断此映射中是否有键 赵六:false

    李四-----23

    张三-----25

    王五-----25

    使用keySet方法获取键值对

    键:李四---值:23

    键:张三---值:25

    键:王五---值:25

    4.2 TreeMap

    TreeMap使用二叉树法对键值对进行排序。排序规则是以键的自然顺序或者是将键按照指定比较器进行排序。

    TreeMap中特有的方法:

    Map.Entry<K,V> ceilingEntry(K key):返回一个键值对关联,它大于等于给定键的最小键的关联,不存在则返回为空

    K ceilingKey(K key): 返回一个键值对关系,它大于等于给定键的最小键,不存在则返回为空。

    Map.Entry<K,V> floorEntry(K key):返回一个键值对关联,它小于等于给定键的最小键的关联,不存在则返回为空

    K floorKey(K key): 返回一个键值对关系,它小于等于给定键的最小键,不存在则返回为空。

    Map.Entry<K,V> fristEntry(K key):返回一个最小键的键值对关联,不存在则返回为空

    K fristKey(K key): 返回一个最小的键,不存在则返回为空。

    Map.Entry<K,V> lastEntry(K key):返回一个最大键的键值对关联,不存在则返回为空

    K lastKey(K key): 返回一个最大的键,不存在则返回为空。

    Map.Entry<K,V> higeherEntry(K key):返回一个键-值映射关系,它与严格大于给定键的最小键关联;如果不存在这样的键,则返回 null

    K higeherKey(K key): 返回严格大于给定键的最小键;如果不存在这样的键,则返回 null

    Map.Entry<K,V> lowerEntry(K key):返回一个键-值映射关系,它与严格小于给定键的最小键关联;如果不存在这样的键,则返回 null

    K lowerKey(K key): 返回严格小于给定键的最小键;如果不存在这样的键,则返回 null

    集中类中各类集合的特点。

     

  • 相关阅读:
    13.Odoo产品分析 (二) – 商业板块(6) –采购(3)
    9.Odoo产品分析 (二) – 商业板块(4) –讨论(1)
    10.Odoo产品分析 (二) – 商业板块(5) –日历(1)
    8.Odoo产品分析 (二) – 商业板块(3) –CRM(2)
    7.Odoo产品分析 (二) – 商业板块(3) –CRM(1)
    the nearest point/vertex point of linestring
    Clojure的引用类型:var,ref,agent和atom
    clojure的delay future promise
    clojure的语法糖
    postgres select TOP X in group 查询每个组的前几名
  • 原文地址:https://www.cnblogs.com/chun2015/p/4932765.html
Copyright © 2011-2022 走看看