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

下面使用代码进行演示：

package Blogs;

 

import java.util.ArrayList;

import java.util.Iterator;

 

public class ArrayListDemo {

 

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       //建立ArrayList集合，并指定集合中的元素类型为String类型。

       ArrayList<String> al=new ArrayList<String>();

      

       //向集合中添加元素

       al.add("黑马");

       al.add("程序员");

       al.add("训练营");

       al.add("!");

       al.add("安卓");

       al.add("就业班");

       al.add("！!");

      

       //获得集合迭代器，将集合中内容迭代打印到控制台

       Iterator it=al.iterator();

       while(it.hasNext()){

           System.out.print(it.next());

       }

       System.out.println("");

      

       //获得集合长度

       System.out.println(al.size()); 

      

       //删除指定位置元素

       System.out.println("删除集合角标为1的元素："+al.remove(1));

      

       //删除指定元素

       System.out.println("删除元素中的 安卓 ："+al.remove("安卓"));   

      

       //将指定位置元素更改为指定元素  

       al.set(3,"基础班");

       Iterator it1=al.iterator();

       while(it1.hasNext()){

           System.out.print(it1.next());

       }

       System.out.println("");

       //清空元素

       al.clear();

       //判断元素是否为空

       System.out.print("元素是否为空："+al.isEmpty()); 

    }

 

}

 

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

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

package Blogs;

 

import java.util.LinkedList;

import java.util.ListIterator;

 

public class LinkedListDemo {

    public static void main(String[] args){

       LinkedList<String>  ll=new LinkedList<String> ();

       //向集合中增加元素

       ll.add("黑马");

       ll.add("程序员");

       ll.add("训练营");

       //向集合头部增加元素

       ll.addFirst("itheima.com");

       //使用ListIterator迭代器，取出集合元素

       ListIterator<String> it=ll.listIterator();

       while(it.hasNext()){

           System.out.print(it.next());

       }

       System.out.println("");

       //获取集合中第一个元素

       System.out.println("集合中第一个元素为："+ll.peekFirst());

       //删除第一个元素

       ll.pollFirst();

       System.out.println("删除第一个元素后、集合中第一个元素变为："+ll.peekFirst());

       //清空集合中元素

       ll.clear();

       //使用peek()，获取空集合中的元素，返回为空

       System.out.print("集合内容为空时，使用peek进行获取元素:"+ll.peek());

    }

}

 

输出结果如下：

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

7

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

删除元素中的 安卓 ：true

黑马训练营!基础班！!

元素是否为空：true

三、     Set实现类

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

3.1 HashSet

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

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

代码示例：

package Blogs;

 

import java.util.HashSet;

import java.util.Iterator;

 

public class HashSetDemo {

 

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       //建立HashSet集合对象

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

       //对象中添加元素

       hs.add(new Student("张三",23));

       hs.add(new Student("李四",21));

       hs.add(new Student("王五",20));

       hs.add(new Student("张三",23));//此时写入失败

       hs.add(new Student("李四",22));

       //建立迭代器，将集合内容进行打印。

       Iterator<Student> it=hs.iterator();

       while(it.hasNext()){

           Student s=it.next();

           System.out.println(s.getname()+"--"+s.getage());

       }

    }

 

}

class Student{

    private String name;

    private int age;

    Student(String name,int age){

       this.name=name;

       this.age=age;

    }

    public String getname() {

       return name;

    }

    public int getage() {

       return age;

    }

    public int hashCode(){

       //复写hashCode方法

       return name.hashCode()+age*54;

      

    }

    public boolean equals(Object o){

       //复写equals方法

       if(!(o instanceof Student))

           return false;

       Student s=(Student)o;

       if(s.name.equals(name)&&s.age==age)

           return true;

       return false;

    }

}

打印结果：

李四--21

张三--23

李四--22

王五—20

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

3.2TreeSet

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

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

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

package Blogs;

 

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

 

public class TreeSetDemo {

 

    public static void main(String[] args) {

       // TODO Auto-generated method stub

      

       System.out.println("按照年龄进行排序");

       //以Person自然排序规则进行排序（按照年龄排序）

       TreeSet<Person> ts=new TreeSet<Person>();

       ts.add(new Person("张三",32));

       ts.add(new Person("李四",33));

       ts.add(new Person("王五",31));

       ts.add(new Person("李四",30));

       ts.add(new Person("博士",32));

       Iterator<Person> it=ts.iterator();

       while(it.hasNext()){

           Person p=it.next();

           System.out.println(p.getname()+"--"+p.getage());

       }

 

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

       System.out.println("按照姓名进行排序");

       //传入比较器，按照比较器进行排序。（按照姓名排序）

       TreeSet<Person> ts1=new TreeSet<Person>(new myPersonCompare());

       ts1.add(new Person("张三",32));

       ts1.add(new Person("李四",33));

       ts1.add(new Person("王五",31));

       ts1.add(new Person("李四",30));

        ts1.add(new Person("博士",32));

       Iterator<Person> it1=ts1.iterator();

       while(it1.hasNext()){

           Person p=it1.next();

           System.out.println(p.getname()+"--"+p.getage());

       }

    }

}

//person类实现Comparable接口，以便使自己有排序规则

class Person implements Comparable<Person>{

    private String name;

    private int age;

    Person(String name,int age){

       this.name=name;

       this.age=age;    

    }

    public String getname(){

       return name;

    }

    public int getage(){

       return age;

    }

    @Override

    //实现 compareTo 方法 按照年龄排序

    public int compareTo(Person o) {

       // TODO Auto-generated method stub

       Person p=(Person)o;

       if(this.age!=p.age)

           return this.age-p.age;

       else

           return this.name.compareTo(p.name);

    }

}

 

//定义比较器

class myPersonCompare implements Comparator<Person>{

 

    @Override

    public int compare(Person p1, Person p2) {

       // TODO Auto-generated method stub

 

       if(p1.getname().equals(p2.getname()))

           return p1.getage()-p2.getage();

       else

           return p1.getname().compareTo(p2.getname());

    }

}

输出结果如下：

按照年龄进行排序

李四--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):判断此映射中是否包含指定值

示例代码：

package Blogs;

 

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

 

public class MapDemo {

 

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       //建立HashMap对象

       HashMap<String,Integer> hm=new HashMap<String,Integer>();

       //添加映射关系

       hm.put("张三", 24);

       hm.put("李四", 23);

       hm.put("王五", 25);

       //添加相同键的映射关系，会替换原来键对应的值

       hm.put("张三", 25);

       System.out.println("hm中的键值对为："+hm);

 

       //判断是否有值“25”

       System.out.println("判断此映射中是否包含值25："+hm.containsValue(25));

       //判断是否有键"赵六"

       System.out.println("判断此映射中是否有键 赵六："+hm.containsKey("赵六"));

       //获取Set对象，使用entrySet()方法输出HashMap中的键值对

       Set<Map.Entry<String,Integer>> s=hm.entrySet();

       for(Map.Entry<String, Integer> m:s){

           System.out.println(m.getKey()+"-----"+m.getValue());

       }

      

       System.out.println("使用keySet方法获取键值对");

       Set<String> s1=hm.keySet();

       for(String sr:s1){

           System.out.println("键："+sr+"---值:"+hm.get(sr));

       }

    }

}

输出结果：

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。

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