`

java学习二(集合类)

    博客分类:
  • java
阅读更多
package com.jihe.mytest;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

/*
* Java容器类类库分类:
Collection:一组独立的元素,通常这些元素都符合某种规则。(例如List必须保持元素特定的顺序,Set不能有重复元素)
Map:一组成对的“键值对”对象。

Collection – 对象之间没有指定的顺序,允许重复元素。
Set –  对象之间没有指定的顺序,不允许重复元素
List–  对象之间有指定的顺序,允许重复元素,并引入位置下标。
Map –  接口用于保存关键字(Key)和数值(Value)的集合,集合中的每个对象加入时 都提供数值和关键字。Map 接口既不继承 Set 也不继承 Collection。

List、Set、Map共同的实现基础是Object数组。

接口      实现               历史集合类
Set  HashSet     
     TreeSet     
List ArrayList   Vector   
     LinkedList  Stack 
Map  HashMap     Hashtable    
     TreeMap     Properties

*/

public class CollectionTest {
public static void main(String[] args){
//Collection
/*
集合(Collection): 
        Collection<String> collection1=new ArrayList<String>();//创建一个集合对象
    collection1.add("000");//添加对象到Collection集合中
    collection1.add("111");
    collection1.add("222");
    System.out.println("集合collection1的大小:"+collection1.size());
    System.out.println("集合collection1的内容:"+collection1);
    collection1.remove("000");//从集合collection1中移除掉 "000" 这个对象
    System.out.println("集合collection1移除 000 后的内容:"+collection1);
    System.out.println("集合collection1中是否包含000 :"+collection1.contains("000"));
    System.out.println("集合collection1中是否包含111 :"+collection1.contains("111"));
    Collection  collection2=new ArrayList();
    collection2.addAll(collection1);//将collection1 集合中的元素全部都加到collection2中
    System.out.println("集合collection2的大小:"+collection2.size());
    System.out.println("集合collection2的内容:"+collection2);
    collection2.clear();//清空集合 collection1 中的元素
    System.out.println("集合collection2是否为空 :"+collection2.isEmpty());
    //将集合collection1转化为数组
    Object s[]= collection1.toArray();
    for(int i=0;i<s.length;i++){
            System.out.println(s[i]);
            }
*/
Collection<String> collection1=new ArrayList<String>();//创建一个集合对象
    collection1.add("000");//添加对象到Collection集合中
    collection1.add("111");
    collection1.add("222");
    System.out.println("集合collection1的大小:"+collection1.size());
    System.out.println("集合collection1的内容:"+collection1);
    collection1.remove("000");//从集合collection1中移除掉 "000" 这个对象
    System.out.println("集合collection1移除 000 后的内容:"+collection1);
    System.out.println("集合collection1中是否包含000 :"+collection1.contains("000"));
    System.out.println("集合collection1中是否包含111 :"+collection1.contains("111"));
    Collection<String>  collection2=new ArrayList<String>();
    collection2.addAll(collection1);//将collection1 集合中的元素全部都加到collection2中
    System.out.println("集合collection2的大小:"+collection2.size());
    System.out.println("集合collection2的内容:"+collection2);
    collection2.clear();//清空集合 collection1 中的元素
    System.out.println("集合collection2是否为空 :"+collection2.isEmpty());
    //将集合collection1转化为数组
    Object s[]= collection1.toArray();
    for(int i=0;i<s.length;i++){
            System.out.println(s[i]);
        }

    //Iterator
/*
迭代器(Iterator)本身就是一个对象,它的工作就是遍历并选择集合序列中的对象,而客户端的程序员不必知道或关心该序列底层的结构
*/
    Collection<String> coll = new ArrayList<String>();
        coll.add("s1");
        coll.add("s2");
        coll.add("s3");
        Iterator iterator = coll.iterator();//得到一个迭代器
        while (iterator.hasNext()) {//遍历
            Object element = iterator.next();
            System.out.println("iterator = " + element);
        }
        if(coll.isEmpty())
            System.out.println("collection is Empty!");
        else
        System.out.println("collection is not empty!");
        

//List
/*
List:是容器的一种,表示列表的意思。对象之间有指定的顺序,允许重复元素,并引入位置下标。
  void add(int index, Object element) :添加对象element到位置index上
  boolean addAll(int index, Collection collection) :在index位置后添加容器collection中所有 的元素
  Object get(int index) :取出下标为index的位置的元素
  int indexOf(Object element) :查找对象element 在List中第一次出现的位置
  int lastIndexOf(Object element) :查找对象element 在List中最后出现的位置
  Object remove(int index) :删除index位置上的元素
  Object set(int index, Object element) :将index位置上的对象替换为element 并返回老的元素
List的实现有两种方式:ArrayList和LinkedList
ArrayList提示快速的基于索引的成员访问,对尾部成员的增加和删除支持较好,成员可为任意Object子类的对象
LinkedList对列表中任何位置的成员的增加和删除支持较好,但对于索引的成员访问支持性能较差,成员可为任意Object子类的对象
因此,如果要支持随机访问,而不必在除尾部的任何位置插入或除去元素,那么,ArrayList 提供了可选的集合。但如果,您要频繁的从列表的中间位置添加和除去元素,而只要顺序的访问列表元素,那么,LinkedList 实现更好。

List接口处理集合的子集:
  ListIterator listIterator() :返回一个ListIterator 跌代器,默认开始位置为0
  ListIterator listIterator(int startIndex) :返回一个ListIterator 跌代器,开始位置为startIndex
  List subList(int fromIndex, int toIndex) :返回一个子列表List ,元素存放为从 fromIndex 到 toIndex之前的一个元素
*/
        List<String> ll = new ArrayList<String>();
    ll.add("aaa");
    ll.add("bbb");
    ll.add("ccc");
    ll.add("ddd"); 
     System.out.println("下标0开始:"+ll.listIterator(0).next());//next()
     System.out.println("下标1开始:"+ll.listIterator(1).next());
    System.out.println("子List 1-3:"+ll.subList(1,3));//子列表
    ListIterator<String> it = ll.listIterator();//默认从下标0开始
    //隐式光标属性add操作 ,插入到当前的下标的前面
    it.add("sss");
    while(it.hasNext()){
    System.out.println("next Index="+it.nextIndex()+",Object="+it.next());
    }  
   
    //set属性
        ListIterator<String> it1 = ll.listIterator();
    it1.next();
    it1.set("ooo");  //将上面设置的sss元素改成ooo
    ListIterator<String> it2 = ll.listIterator(ll.size());//下标
        while(it2.hasPrevious()){
        System.out.println("previous  Index="+it2.previousIndex()+",Object="+it2.previous());
        }
       
    //Map
/*
Map:不是 Collection 接口的继承,而是从自己的用于维护键-值关联的接口层次结构入手。按定义,该接口描述了从不重复的键到值的映射。
  Object put(Object key,Object value):用来存放一个键-值对Map中
  Object remove(Object key):根据key(键),移除一个键-值对,并将值返回
  void putAll(Map mapping) :将另外一个Map中的元素存入当前的Map中
  void clear() :清空当前Map中的元素
  Object get(Object key) :根据key(键)取得对应的值
  boolean containsKey(Object key) :判断Map中是否存在某键(key)
  boolean containsValue(Object value):判断Map中是否存在某值(value)
  int size():返回Map中 键-值对的个数
  boolean isEmpty() :判断当前Map是否为空
  public Set keySet() :返回所有的键(key),并使用Set容器存放。因为映射中键的集合必须是唯一的,就使用 Set 来支持。
  public Collection values() :返回所有的值(Value),并使用Collection存放。因为映射中值的集合可能不唯一,就使用 Collection 来支持。
  public Set entrySet() :返回一个实现 Map.Entry 接口的元素 Set

Map的实现:
HashMap:能满足用户对map的通用需求。键成员可以为任意的Object子类的对象,但如果覆盖了equals方法,同时注意修改hashCode方法。
TreeMap:支持对键有序的遍历,使用时建议先用HashMap增加和删除成员,最后从HashMap生成TreeMap;附加实现了SortedMap接口,支持子Map等要求顺序的操作。键成员要求实现Compareble接口,或者使用Comparator构造TreeMap,键成员一般为同一类型。
LinkedHashMap:保留键的插入顺序,用equals方法检查键和值的相等性。成员可为任意的Object子类对象,但如果覆盖了equals方法,同时注意修改hashCode方法。
*/
        Map<String,String> map1 = new HashMap<String,String>();
        Map<String,String> map2 = new HashMap<String,String>();
        map1.put("1","aaa1");
        map1.put("2","bbb2");   
        map2.put("10","aaaa10");
        map2.put("11","bbbb11");
        //根据键 "1" 取得值:"aaa1"
        System.out.println("map1.get(1)="+map1.get("1"));
        // 根据键 "1" 移除键值对"1"-"aaa1"
        System.out.println("map1.remove(1)="+map1.remove("1"));
        System.out.println("map1中键值对的个数:"+map1.size());
        System.out.println("map1.get(1)="+map1.get("1"));
        map1.putAll(map2);//将map2全部元素放入map1中
        map2.clear();//清空map2
        System.out.println("map1 IsEmpty?="+map1.isEmpty());
        System.out.println("map2 IsEmpty?="+map2.isEmpty());
        System.out.println("map1 中的键值对的个数size = "+map1.size());
        System.out.println("KeySet="+map1.keySet());//set
        System.out.println("values="+map1.values());//Collection
        System.out.println("entrySet="+map1.entrySet());    
        System.out.println("map1 是否包含键:11 = "+map1.containsKey("11"));
        System.out.println("map1 是否包含值:aaa1 = "+map1.containsValue("aaa1"));
   
        //Map的排序

        Map<Integer,String> m1 = new HashMap<Integer,String>();
        Map m2 = new LinkedHashMap();
        for(int i=0;i<3;i++){
        double sr=Math.random()*100;//产生一个随机数,并将其放入Map中
        m1.put(new Integer((int) sr),"第 "+i+" 个放入的元素:"+sr+"¥n");
            m2.put(new Integer((int) sr),"第 "+i+" 个放入的元素:"+sr+"¥n");
        }
        System.out.println("未排序前HashMap:"+m1);   //HashMap的存入顺序和输出顺序无关
        System.out.println("未排序前LinkedHashMap:"+m2);   //LinkedHashMap的输出顺序与存入顺序相同
        //使用TreeMap来对另外的Map进行重构和排序
        Map sortedMap = new TreeMap(m1);  //TreeMap是对Map中元素进行排序
        System.out.println("排序后:"+sortedMap);
        System.out.println("排序后:"+new TreeMap(m2));
       
       
        //Set
/*
* Set:继承 Collection 接口,而且它不允许集合中存在重复项。
     public int size() :返回set中元素的数目,如果set包含的元素数大于Integer.MAX_VALUE,返回Integer.MAX_VALUE
  public boolean isEmpty() :如果set中不含元素,返回true
  public boolean contains(Object o) :如果set包含指定元素,返回true
  public Iterator iterator() :返回set中元素的迭代器;元素返回没有特定的顺序,除非set是提高了该保证的某些类的实例
  public Object[] toArray() :返回包含set中所有元素的数组
  public Object[] toArray(Object[] a) :返回包含set中所有元素的数组,返回数组的运行时类型是指定数组的运行时类型
  public boolean add(Object o) :如果set中不存在指定元素,则向set加入     
  public boolean remove(Object o) :如果set中存在指定元素,则从set中删除        
  public boolean removeAll(Collection c) :如果set包含指定集合,则从set中删除指定集合的所有元素      
  public boolean containsAll(Collection c) :如果set包含指定集合的所有元素,返回true。如果指定集合也是一个set,只有是当前set的子集时,方法返回true     
  public boolean addAll(Collection c) :如果set中中不存在指定集合的元素,则向set中加入 所有元素
  public boolean retainAll(Collection c) :只保留set中所含的指定集合的元素(可选操作)。 换言之,从set中删除所有指定集合不包含的元素。 如果指定集合也是一个set,那么该操作修改set的效果是使它的值为两个set的交集
  public void clear() :从set中删除所有元素

Set的常用实现类:
HashSet:外部无序地遍历成员。成员可为任意Object子类 的对象,但如果覆盖了equals方法,同时注意修改hashCode方法
TreeSet:外部有序地遍历成员;附加实现了SortedSet,支持子集等要求顺序的操作。成员要求实现 Comparable接口,或者使用Comparator构造 TreeSet。成员一般为同一类型。
LinkedHashSet:外部按成员的插入顺序遍历成员。成员与HashSet成员类似。
*/
        Set set1 = new HashSet();
        if (set1.add("a")) {//添加成功            
        System.out.println("1 add true");
        }
        if (set1.add("a")) {//添加失败
            System.out.println("2 add true");
        }else{
        System.out.println("2 add failed");
        }
        set1.add("000");//添加对象到Set集合中
        set1.add("111");
        set1.add("222");
        System.out.println("集合set1的大小:"+set1.size());
        System.out.println("集合set1的内容:"+set1);
        set1.remove("000");//从集合set1中移除掉 "000" 这个对象
        System.out.println("集合set1移除 000 后的内容:"+set1);
        System.out.println("集合set1中是否包含000 :"+set1.contains("000"));
        System.out.println("集合set1中是否包含111 :"+set1.contains("111"));
        Set set2=new HashSet();
        set2.add("111");
        set2.addAll(set1);//将set1 集合中的元素全部都加到set2中
        System.out.println("集合set2的内容:"+set2);
        set2.clear();//清空集合 set1 中的元素
        System.out.println("集合set2是否为空 :"+set2.isEmpty());
        Iterator iterator1 = set1.iterator();//得到一个迭代器
        while (iterator1.hasNext()) {//遍历
            Object element = iterator1.next();
            System.out.println("iterator = " + element);
        }
        //将集合set1转化为数组
        Object ss[]= set1.toArray();
        for(int i=0;i<ss.length;i++){
            System.out.println(ss[i]);
        }
        //Set排序
        Set<Integer> s1 = new HashSet<Integer>();
        Set<Integer> s2 = new LinkedHashSet<Integer>();
        for(int i=0;i<5;i++){
        int ssss=(int) (Math.random()*100);  //产生一个随机数,并将其放入Set中
        s1.add(new Integer(ssss));
        s2.add(new Integer(ssss));
        System.out.println("第 "+i+" 次随机数产生为:"+ssss);
        }
        System.out.println("未排序前HashSet:"+s1);
        System.out.println("未排序前LinkedHashSet:"+s2);
        //使用TreeSet来对另外的Set进行重构和排序
        Set<Integer> sortedSet = new TreeSet<Integer>(s1);
        System.out.println("排序后的HashSet :"+sortedSet);
        System.out.println("排序后的LinkedHashSet :"+new TreeSet(s2));
    }
}
分享到:
评论

相关推荐

    JAVA基础集合类学习.md

    JAVA基础集合类学习.md

    java 集合和内部类资料

    在`Java集合排序及java集合类详解.PDF`文档中,你可以找到关于集合排序和不同集合类的详细讲解。例如,如何使用Collections.sort()方法对List进行排序,以及如何自定义比较器Comparator实现复杂排序逻辑。对于Map,...

    java集合类的代码

    这个压缩包文件“Collection”很可能包含了关于Java集合类的一些示例代码,这些代码可以用于理解和学习如何在实际项目中应用这些集合。 Java集合框架主要由两个接口层次构成:Collection和Map。Collection是所有单...

    java集合类学习汇总

    总结起来,Java集合类的学习不仅仅是了解每个类的基本用法,更关键的是理解它们背后的实现原理和数据结构,以便根据实际需求选择最合适的集合类。通过深入学习和实践,我们可以提高代码的效率和可维护性,更好地应对...

    JAVA学习Java集合框架.pptx

    JAVA集合框架学习笔记 JAVA集合框架是Java语言中提供的一种数据结构,用于存储和管理大量数据。它提供了多种接口和实现类,例如Collection、List、Map等,帮助开发者更方便地处理数据。 什么是异常? 在Java中,...

    java集合深度学习

    在深入学习Java集合时,我们需要特别关注HashMap和HashTable这两个重要的类。虽然它们都是用于存储键值对的数据结构,但它们在设计和使用上有显著的区别。 HashMap是Java 1.2引入的,它是Map接口的一个实现,提供了...

    深入Java集合学习系列

    在"深入Java集合学习系列(二):ArrayList实现原理_尚硅谷_张晓飞.pdf"中,你可以了解到ArrayList的内部结构、扩容机制以及其在不同操作下的性能特点。 其次,HashMap是Java中处理键值对的数据结构,它实现了Map接口...

    大公司最喜欢问的Java集合类面试题

    ### Java集合类重要知识点 #### 一、概述 在Java编程中,集合类是一个非常...通过以上内容的学习,我们可以更好地理解Java集合类的基本概念和使用方法,这对于通过大公司的技术面试至关重要。希望本文对你有所帮助!

    java中常用集合类和接口.doc

    #### 二、为什么使用集合类 在实际开发中,经常会遇到不知道数据确切数量的情况,或者需要比数组更灵活的存储和访问机制。这时,集合类就能派上用场。它们不仅能够高效地存储和管理大量数据,还能提供丰富的操作接口...

    细说Java之常用集合类.rar

    "下载说明.txt"可能包含获取更多资源的指南,如"A5下载- 更全的站长资源平台.url"可能是一个提供Java学习资料的网站链接,可以作为进一步学习的参考。 总之,掌握Java的集合类对于任何Java开发者来说都至关重要,这...

    java 集合类讲解

    Java集合类是Java编程语言中一个非常重要的概念,它提供了数据结构和算法的实现,使得开发者可以方便地存储、管理和操作对象。Java集合框架包括多种接口(如List、Set、Queue)和实现这些接口的类(如ArrayList、...

    java实验数组和集合

    Java 集合框架提供了多种集合类,包括ArrayList、LinkedList、HashSet 等。 在本实验中,我们没有直接使用集合,而是使用数组来实现实验题目。但是,集合可以用来实现更加灵活和高效的数据存储和操作。 Java 数组...

    java学习路线(鱼皮)

    Java学习路线(鱼皮) Java学习路线(鱼皮)是一条龙版本的学习路线,从入门到入土,旨在帮助学习者快速掌握Java开发的所有知识点。本路线的特点是新、完整、实用、开源、回馈社区、持续更新。 学习路线的主要...

    JAVA学习——集合与三层设计模式

    在Java编程语言中,集合和三层设计模式是两个非常重要的概念,对于开发高效、可维护的软件系统至关重要。本文将详细探讨这两个主题。...希望这个Java学习课件能帮助到正在学习Java的你,让你在编程之路上更进一步。

    java集合分类总结.doc

    学习Java集合需要掌握以下几个方面: 1. 怎样得到(选择)集合对象 2. 怎样添加元素 3. 怎样删除元素 4. 怎样循环遍历每一个元素 在实际开发中,Java集合是非常重要的,掌握Java集合的使用可以提高开发效率和代码...

    java集合类的相关资料

    Java集合框架是Java编程语言中的一个核心组成部分,它为存储、管理和操作对象提供了一组统一的接口和类。...这份资料中的“集合类.doc”和“java_集合.pdf”将深入讲解这些概念,是学习和提升Java集合知识的宝贵资源。

    Java集合类PPT学习教案.pptx

    Java集合类是Java编程语言中一个非常重要的概念,它们提供了数据结构和算法的实现,使得开发者能够更加高效地管理和操作数据。在Java中,集合类主要用于存储和操作对象,弥补了数组的一些不足,如动态扩展、灵活性...

    java集合与通用集合

    首先,集合框架的核心是`Collection`接口,它是所有集合类的根接口。`Collection`有两个主要的子接口:`Set`和`List`,它们分别代表不同的数据结构。`Set`接口确保集合中的元素唯一,不允许重复,并且支持数学集合...

Global site tag (gtag.js) - Google Analytics