zoukankan      html  css  js  c++  java
  • 11.集合类

    1.主要组成是一些核心的操作接口:
     collection,list,set,map,iterator,enumeration
    2.提到容器不难想到集合类与数组的不同之处是:
    1.数组的长度是固定的,集合的长度是可变的;
    2.数组用来存放基本数据类型的数据,集合用来存放对象的引用。
    3.常用的集合有:
    List集合,Set集合和Map集合,其中List与set继承了Collection接口,各接口还提供了不同的实现类。
    4.集合的分类
    1.单列集合(collection)
    2.双列集合(map)
    5.双列集合的根接口-collection接口
    单列集合的根接口,用于存放一系列符合某种规则的元素。构成collection的单位称为元素。该接口通常不能直接使用,但该接口提供了添加元素,删除元素,管理数据的方法。由于List接口和set接口都继承了Collection接口,因此这些方法对List集合与set集合是通用的。
    常用的方法如下表所示:
    1.add(E e)    将指定的对象添加到集合中
    2.remove(object o)  将指定的对象从集合中移除
    3.isEmpty()  返回Boolean值,用于判断当前集合是否为空
    4.iterator()    返回在此Collection的元素上进行迭代的迭代器(返回一个Iterator的对象)。用于遍历集合中的对象
    5.size()    返回int型值,获取该集合中的元素的个数
    6.集合的输出操作
    如何遍历集合中的每个元素呢?
    java类集中给出了四种输出方式:
    1.迭代输出:Iterator
    Iterator是专门的迭代输出接口,所谓的迭代输出就是对元素逐个判断,判断其是否与内容,如果有内容则把内容取出
    此接口在使用时也要指定泛型,当然在此处指定的泛型类最好与集合中的泛型一致。此接口定义了三个方法
    (1)public boolean hasnext() 判断是否有下一个值
    (2)public E next() 取出当前元素   返回的是泛型,需要指定类型
    (3) public void remove() 移除当前元素
    如何取得Iterator接口的实例化对象呢?这一操作在Collection接口中已明确定义了,因为collection继承了一个Iterator接口,在这个Iterator定义了一个方法"public Iterator<E> iterator()"
    2.ListIterator
    是Iterator的子接口,添加了两个扩充方法
    (1)public boolean hasPrevious()     判断是否有前一个元素
    (2)public E previous()   取出前一个元素
    public class for_demo {
    public static void main(String[] args) throws Exception {
     
    List<String> list = new ArrayList<>();// 子类为接口实例化,向上转型
    list.add("a");
    list.add("b");
    list.add("c");
    ListIterator<String> it = list.listIterator();// public Iterator<E> iterator()),返回一个Iterator<String>类型的数据
    System.out.println("从前往后输出:");
     
    while (it.hasNext()) {
    String str = (String) it.next();
    System.out.println(str);
    }
     
    System.out.println("从后往前输出:");
     
    while (it.hasPrevious()) {
     
    String str2 = it.previous();
    System.out.println(str2);
    }
     
    }
    }
     
    对于从后向前输出操作,在进行前一定首先发生从前往后的操作,只适用与list故在开发中很少用
    3.Enumeration
    最早的接口,称为枚举输出
    (1)public boolean hasMoreElements()  判断是否有下一个值
    (2)public E nextElement()    取出当前元素
    在程序中,如果要取得Enumeration的实例化对象,只能依靠Vector类完成,在Vector类中定义了方法public Enumeration<E> elements() 返回Enumeration的对象
    public class for_demo {
    public static void main(String[] args) throws Exception {
     
    Vector<String> list = new Vector<String>();// 子类为接口实例化,向上转型
    list.add("a");
    list.add("b");
    list.add("c");
    Enumeration<String> it = list.elements();// public Iterator<E> iterator()),返回一个Iterator<String>类型的数据
     
    while (it.hasMoreElements()) {
    String str = (String) it.nextElement();
    System.out.println(str);
    }
     
    }
    }
    jsp中的getParameterNames();返回的就是Enumertion.会用到这个方法
    4.foreach
    public class for_demo {
    public static void main(String[] args) throws Exception {
     
    Vector<String> list = new Vector<String>();// 子类为接口实例化,向上转型
    list.add("a");
    list.add("b");
    list.add("c");
    for(String str:list) {
    System.out.println(str);
    }
     
    }
    }
     
    7.一般操作
    public Iterator<E> iterator())
    public class MUster{
    public static void main(String args[]){
    Collection<String>list=new ArrayList<>();// //实例化集合类对象 list,类型是String
    list.add("a");
    list.add("b");
    list.add("c");
    iterator<String> it=list.iterator();//创建迭代器
    while(it.hasNext()){  //判断是否有下一个元素
    String str=(String)it.next(); 获取下一个元素
    System.out.println(str);
    }
    }
    }
    7.List集合
    list集合包括List接口以及List接口的所有实现类。List集合中的元素允许重复,各元素的顺序就是对象插入的顺序。类似数组,用户可以通过使用索引来访问集合中的元素,另外一个特点就是元素有序,即元素的存入顺序和取出顺序一致,LIst接口继承了Collection接口,因此包含collection中的所有方法。
    此外,list接口还定义了两个非常重要的方法
    get( int index)
    set(int index,Object object);
    8.  List接口的实现类
    List接口的常用的实现类有ArrayLsit与LinkedList.
    .ArrayList类实现了可变的数组,允许保存所有元素,包括null并可以根据索引的位置对集合进行快速的随机访问:缺点是向指定的索引位置插入对象或删除对象的速度较慢。
    .LinkedList类采用链表结构保存对象。这种结构的优点是便于向集合中插入和删除对象,需要向集合中插入,删除对象时,使用LinkList类实现的List集合的效率较高;但对于随机访问集合中的对象,使用LinkedList类实现List集合的效率较低
    List<E> list1=new ArrayList<>();
    List<E> list2=new LinkedList<>();
    在上面的代码中,E可以是合法的Java数据类型。
    成num1到num2的随机数[num1,num2)
    公式:int s=(int)num1+(int)(Math.random()*(num2-num1));
    public class gather{
    public static void main(String[] args){
    List<String> list=new ArrayLIst<>();//
    list.add("a");
    list.add("b");
    list.add("c");
    int i=(int)(Math.Random()*list.size());//包括0
    System.out.println("随机获取数组中的元素:“+list.get(i));
    list.remove(2);
    System.out.println("将索引是”2‘的元素从数组中移除后,数组中的元素是:);
    for(int j=0;j<list.size();j++){
    System.out.println(list.get(j));
    }
    }
    }
     
    9.set集合
    set集合中的对象不按特定的方式排序,只是简单的把对象加入集合中,但set集合中不能包含重复对象。set集合由set接口和set接口的实现类组成 。set接口继承了Collection接口,因此包含collection接口的所有方法。
    set接口常见的实现类有:
    (1)HashSet类
    Hashset类实现Set接口,由哈希表(实际上是一个hashmap的实例)支持,不保证set的迭代顺序,特别是他不保证该顺序不变。允许使用null元素。
    public class MapText {
    public static void main(String[] args) {
     
    Set<String> all = new HashSet<String>();
    all.add("蔡震");
    all.add("加油");
    Iterator it = all.iterator();
    while (it.hasNext()) {
    String str = (String) it.next();
    System.out.println(str);
    }
     
    }
    }
    (2)Treeset类
    TreeSet类不仅实现了set接口,还实现了java.util.SortedSet接口,因此,TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序,也可以按照指定比较器递增顺序,即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。TreeSet类新增的方法
    (1).first() 返回此Set中当前第一个(最低)元素
    (2).last()   返回此Set中当前最后一个(最高)元素
    (3).comparator()  返回对此Set中的元素进行排序的比较器。如果set使用自然顺序,则返回null
    (4).headSet(E toElement)   返回一个新的Set集合,新集合是toElement(不包含)之前的所有对象。
    (5).subSet(E fromElement,E fromElement); 返回一个新的set集合,是fromElement(包含)与fromElement(不包含)对象之间的所有对象
    (6).tailSet(E fromElement):返回一个新的Set集合,新集合包含对象fromElement(包含)之后的所有对象。
    public static void main(String[] args) {
     
    Set<String> all = new TreeSet<String>();
    all.add("b");
    all.add("a");
    Iterator it = all.iterator();
    while (it.hasNext()) {
    String str = (String) it.next();
    System.out.println(str);
    }
     
    }
     
    这个集合没有重复的数据,并且按照数据的大小顺序保存数据了。
    实现例子
    public class UpdataStu implements Comparable<Object>{
     
     
    private String name;
    private long id;
     
    public UpdataStu (String name,Long id){
    this.id=id;
    this.name=name;
    }
     
    //存入TreeSet类实现的Set集合必须实现Comparable接口,该接口中的compareTo(object o)方法比较此对象与指定对象的顺序。如果该对象小于,等于或大于指定对象,返回负整数,0,正整数。
    @Override
    public int compareTo(Object o){
    UpdataStu upstu=(UpdataStu)o;
    int result =id>upstu.id? 1 : (id==upstu.id? 0:-1);
    return result;
    }
     
    public String getName() {
    return name;
    }
     
    public void setName(String name){
    this.name=name;
    }
    public long getiD(){
    return id;
    }
    public void setiID(Long id){
    this.id=id;
    }
    public static void main(String[] args){
    UpdataStu stu1=new UpdataStu("李同学",01011L);
    UpdataStu stu2=new UpdataStu("陈同学",01012L);
    UpdataStu stu3=new UpdataStu("王同学",01013L);
    UpdataStu stu4=new UpdataStu("马同学",01014L);
    TreeSet<UpdataStu> tree =new TreeSet<>();  //实例化集合类对象 Tree,类型是UpdataStu
    tree.add(stu1);
    tree.add(stu2);
    tree.add(stu3);
    tree.add(stu4);
    Iterator<UpdataStu>   it=tree.iterator(); //创建迭代器
    System.out.println("Set集合中的所有元素:");
    while(it.hasNext()){
    UpdataStu stu=(UpdataStu) it.next();//获取当前对象
    System.out.println(stu.getiD()+" "+stu.getName());
    }
    //headSet(E toElement)   返回一个新的Set集合,新集合是toElement(不包含)之前的所有对象。
    it=tree.headSet(stu2).iterator();
    System.out.println("截取前面部分的集合");
    while(it.hasNext()){
    UpdataStu stu=(UpdataStu) it.next();//获取当前对象
    System.out.println(stu.getiD()+" "+stu.getName());
     
    }
    it=tree.subSet(stu2,stu3).iterator();//subSet(E fromElement,E fromElement); 返回一个新的set集合,是fromElement(包含)与fromElement(不包含)对象之间的所有对象
    System.out.println("截取前面部分的集合");
    while(it.hasNext()){
    UpdataStu stu=(UpdataStu) it.next();
    System.out.println(stu.getiD()+"  "+stu.getName());
    }
     
    }
    }
     
    9.Map集合
    map集合没有继承Collection接口,其提供的是key,value的映射。Map中不能包含相同的key,每个key最多只能映射一个value。是key还决定了存储对象在映射中的存储位置,但不是key本身决定的,而通过一种”散列技术“进行处理,产生一个散列码的整数值。散列码通常作一个偏移量,该偏移量对应分配给映射内存区域的起始位置,从而确定存储对象在映射中的存储位置。
    map集合包括Map集合以及map集合的实现类
    (1).map接口
    一个映射不能包含重复的key,每个key最多映射一个值。
    1.put(K key,V value):向集合中添加指定的key和value的映射关系
    2.containsKey(Object key):如果此映射包含指定的key的映射到指定值,返回true
    3.cotainsValue(Object value):如果此映射包含将一个或多个key的映射到指定的valeu值,返回true
    4.get(object key):如果存在指定的key对象,则返回该对象对应的值,否则返回null
    5.keySet():返回该集合中的所有key对象形成的Set集合。
    6.values():返回该集合中的所有值对象形成的collection集合
    7.entrySet():返回一个map所有的映射关系形成的Set集合
    public class UpdataStu {
    private String name;
    private String id;
    public UpdataStu(String name,String id){
    this.name=name;
    this.id=id;
    }
    @Override
    public String toString() {
    return id+" "+name;
    }
    public static void main(String[] args){
    Map<String,UpdataStu> map=new HashMap<>();//两个字符串分别为map中的key和value
    UpdataStu stu=new UpdataStu("蔡震","201511010535");
    UpdataStu stu1=new UpdataStu("赵灵","201611010535");
    map.put("1",stu);
    map.put("2", stu1);
     
    Set<String> set=map.keySet();//构建Map集合中所有的Key对象的Set集合
     
    Iterator<String> it=set.iterator();//;创建集合迭代器
     
    System.out.println("key集合中的元素");
     
    while(it.hasNext()){
     
    System.out.println(it.next());//next方法返回的是Object
    }
     
     
    Collection<UpdataStu> coll=map.values();//构建map集合中所有values值的collection集合
     
    Iterator<UpdataStu> itr=coll.iterator();//;创建集合迭代器
     
    System.out.println("value集合中的元素");
     
    while(itr.hasNext()){                       //遍历集合
     
    System.out.println(itr.next());
    }
    }
     
    (2).map集合的实现类
    常见的实现类有
    (1)Hashmap
    (1)建议使用HashMap类实现map集合,因为有Hash类实现map集合添加和删除映射关系效率更高。hashmap是基于哈希表的MAP接口的实现,hashmap通过哈希码对其内部的映射关系进行快速查找
    (2)hashmap类是基于哈希表的map接口的实现,此实现提供所有的可选的映射操作,并允许使用null值和null键,但保证键的唯一性。hashmap通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序,特别是他不保证该顺序的恒久不变。
    (2)treemap.
    (1)Treemap中的映射关系存在一定的顺序,如果希望MAP集合中的对象也存在一定的顺序。应该使用Treemap类实现MAP集合。
    (2).treemap类不仅实现Map接口,还实现了java.util.SortedMap接口,因此,集合中的映射关系具有一定的顺序。但在添加,删除和定位映射关系时,Treemap类比hashmap类性能稍差。由于TreeMAP类实现的map集合中的映射关系是根据键对象按照一定的顺序排列的,因此不允键对象是null.
    (3)可以通过Hashmap类创建Map集合,当需要顺序输出是,再创建一个完成相同映射关系的
     
    Treemap类实例。
    package ceshi;
     
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    import java.util.TreeMap;
     
    class Stu {
     
    String name;
    String id;
     
    public Stu(String name, String id) {
    this.name = name;
    this.id = id;
     
    }
     
    public String getName() {
    return name;
    }
     
    public void setName(String name) {
    this.name = name;
    }
     
    public String getId() {
    return id;
    }
     
    public void setId(String id) {
    this.id = id;
    }
     
    }
     
    public class MapText {
    public static void main(String[] args) {
     
    Map<String, String> map = new HashMap<>();
     
    Stu stu1 = new Stu("李同学", "01011");
    Stu stu2 = new Stu("陈同学", "01012");
    Stu stu3 = new Stu("王同学", "01013");
    Stu stu4 = new Stu("马同学", "01014");
          //put方法向集合中添加指定的Key,value的映射关系
    map.put(stu1.getName(), stu1.getId());
    map.put(stu2.getName(), stu2.getId());
    map.put(stu3.getName(), stu3.getId());
    map.put(stu4.getName(), stu4.getId());
         //keySet方法返回该集合中的所有的Key对象形成的Set集合
    Set<String> set = map.keySet();
    //创建迭代器
    Iterator<String> it = set.iterator();
     
    System.out.println("HashMap类实现的Map集合,无序:");
     
    while (it.hasNext()) {
    //next()取出当前元素,key形成的set集合
    String str = (String) it.next();
    //get(object key):如果存在指定的key对象,则返回该对象对应的值,否则返回null
    String str1=(String)map.get(str);
    System.out.println(str+" "+str1);
    }
     
     
     
    TreeMap<String, String> treemap = new TreeMap<>();
     
    // 向集合中添加对象
    treemap.put(stu1.getName(), stu1.getId());
    treemap.put(stu2.getName(), stu2.getId());
    treemap.put(stu3.getName(), stu3.getId());
    treemap.put(stu4.getName(), stu4.getId());
     
    Iterator<String> iter = treemap.keySet().iterator();
     
    System.out.println("treeMap类实现的Map集合,有序:");
    while (iter.hasNext()) {
     
    String str = (String) iter.next();// 获取集合中的所有key对象
     
    String name = (String) treemap.get(str);// 遍历Map集合,通过key返回对象的值
     
    System.out.println(str + " " + name);
    }
     
     
    }
    }
     
    强化训练的demo
    package ceshi;
     
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.*;
     
    public class Test {
    public static void main(String[] args) {
    // 集合类强化训练
    HashMap<String, String> map_student = new HashMap();
    HashMap<String, String> map_teacher = new HashMap();
     
    map_student.put("20151101053", "蔡震");
    map_student.put("20151101052", "刘聪");
    map_student.put("20151101041", "闫世鑫");
     
    map_teacher.put("001", "张老师");
    map_teacher.put("002", "李老师");
    map_teacher.put("003", "马老师");
    List<Map<String, String>> list = new ArrayList();
    list.add(map_student);
    list.add(map_teacher);
    Iterator it1 = list.iterator();
    while (it1.hasNext()) {
    Map map = (Map) it1.next();
    Set<Map.Entry<String, String>> set = map.entrySet();
    Iterator it2 = set.iterator();
     
    while (it2.hasNext()) {
     
    Map.Entry<String, String> demo = (Map.Entry<String, String>) it2.next();
    String number = (String) demo.getKey();
    String name = (String) demo.setValue(number);
     
    System.out.println(number + " " + name);
    }
    }
     
    }
    }
     
     
  • 相关阅读:
    猜拳游戏GuessGame源码
    基于vitamio的网络电视直播源码
    EarthWarrior3D游戏ios源码
    类似material design的电影应用源码
    四季电台应用项目源码
    高仿一元云购IOS应用源码项目
    非常不错的点餐系统应用ios源码完整版
    仿哔哩哔哩应用客户端Android版源码项目
    《你最美》换发型应用源码
    最新win7系统64位和32位系统Ghost装机稳定版下载
  • 原文地址:https://www.cnblogs.com/cainame/p/10092020.html
Copyright © 2011-2022 走看看