`

java的集合类【转】

阅读更多
在JDK API中专门设计了一组类,这组类的功能就是实现各种各样方式的数据存储,这样一组专门用来存储其它对象的类,一般被称为对象容器类,简称容器类,这组类和接口的设计结构也被统称为集合框架(Collection Framework)。
这组类和接口都包含在java.util包中。

为了使整个集合框架中的类便于使用,在设计集合框架时大量的使用接口,实际实现的功能类实现对应的接口,这样可以保证各个集合类的使用方式保持统一。

在集合框架中,提供的存储方式共有两种:
1、按照索引值操作数据
在这种存储方式中,为每个存储的数据设定一个索引值,存储在容器中的第一个元素索引值是0,第二个索引值是1,依次类推。在操作数据时按照索引值操作对应的数据,实现这种方式的集合类都实现java.util.Collection接口。
2、按照名称操作数据
在这种存储方式中,为每个存储的数据设定一个名称(任意非null的对象都可以作为名称),以后按照该名称操作该数据,要求名称不能重复,每个名称对应唯一的一个值。这种存储数据的方式也称作名称-数值对,也就是名值对存储。实现这种方式的几个类都实现java.util.Map接口。

这里“按照索引值操作数据”的存储方式,又按照容器内部是否能够存储重复的元素,划分成两类:
1、允许存储重复元素。
这种存储方式中,所有的类都实现了java.util.List接口。
2、不允许存储重复元素。
这种存储方式中,所有的类都实现了java.util.Set接口。

这样,集合框架中的类就分成了三大类:
1、List系列
该系列中的类按照索引值来操作数据,允许存放重复的元素。
2、Set系列
该系列中的类按照索引值来操作数据,不允许存放重复的元素。
3、Map系列
该系列中的类按照名称来操作数据,名称不允许重复,值可以重复,一个名称对应一个唯一的值。

而 在数据结构中,实现数据的存储又可以使用不同的数据结构类型进行存储,例如数组、链表、栈、队列和树等,则以上三类集合框架可以使用不同的数据结构类进行 实现,使用每种数据结构则具备该中数据结构的特点。例如使用数组则访问速度快,使用链表则便于动态插入和删除等,这样就造成了集合框架的复杂性。
另外,在将对象存储到集合类中,为了加快存储的速度,要求被存储对象的类中必须覆盖equals方法和hashCode方法。
对于这些集合类,下面按照以上三个系列的顺序一一进行说明。
9.6.3.1 List系列

    List系列的类均实现List接口,大部分的类都以List作为类名的后缀,也有部分该体系中的类命名比较特殊。

         该系列中的类,比较常见的有ArrayList和LinkedList两个。其中ArrayList是以数组为基础实现的List,而LinkedList则是以链表为基础实现的List,ArrayList拥有数组的优点,而LinkedList拥有链表的优点。

         由于该体系中的类均实现List接口,所以在这些类的内部,相同的功能方法声明是保持一致的,下面进行一一介绍:

a、add方法
boolean add(Object o)
该方法的作用是追加对象o到已有容器的末尾。
另外一个add方法:
 void add(int index, Object element)

该方法的作用是将对象element插入到容器中索引值为index的位置,原来位于该位置的对象以及后续的内容将依次向后移动。

b、addAll方法
boolean addAll(Collection c)

该方法的作用是将容器对象c中的每个元素依次添加到当前容器的末尾。

另外一个addAll方法:
 boolean addAll(int index, Collection c)

该方法的作用是将容器对象c中的第一个元素插入到当前容器中索引值为index的位置,第二个元素插入到当前容器中索引值为index+1的位置,依次类推。而当前容器中原来位于index以及index索引值以后的元素则依次向后移动。

c、get方法
Object get(int index)

该方法的作用是返回当前容器对象中索引值为index的元素的内容。

d、indexOf方法
 int indexOf(Object o)


该方法的作用是查找当前容器中是否存在对象o,如果存在则返回该对象第一次出现位置的索    引值,如果不存在则返回-1。
另外一个方法lastIndexOf则是从末尾向前查找,返回从末尾向前第一次出现位置的索引值, 如果不存在则返回-1。
e、remove方法
Object remove(int index)

该方法的作用是删除索引值为index的对象的内容,如果删除成功则返回被删除对象的内容。
另外一个remove方法:
boolean remove(Object o)

该方法的作用是删除对象内容为o的元素,如果相同的对象有多个,则只删除索引值小的对象。如果删除成功则返回true,否则返回false。

无论使用哪一个remove方法,类内部都自动移动将被删除位置后续的所有元素向前移动,保证索引值的连续性。

f、set方法
Object set(int index, Object element)

该方法的作用是修改索引值为index的内容,将原来的内容修改成对象element的内容。

g、size方法
 int size()

该方法的作用是返回当前容器中已经存储的有效元素的个数。

h、toArray方法
 Object[] toArray()

该方法的作用是将当前容器中的元素按照顺序转换成一个Object数组。

下面是一个简单的以ArrayList类为基础实现的List系列中类基本使用的示例,代码如下:

import java.util.*;

/**

 * 以ArrayList类为基础演示List系列类的基本使用

 */

public class ArrayListUse {

         public static void main(String[] args) {

                   //容器对象的初始化

                   List list = new ArrayList();                 

                   //添加数据

                   list.add("1");

                   list.add("2");

                   list.add("3");

                   list.add("1");

                   list.add("1");            

                   //插入数据

                   list.add(1,"12");               

                   //修改数据

                   list.set(2, "a");                  

                   //删除数据

                   list.remove("1");              

                   //遍历

                   int size = list.size(); //获得有效个数

                   //循环有效索引值

                   for(int i = 0;i < size;i++){

                            System.out.println((String)list.get(i));

                   }

         }

}

该程序的运行结果为:

12

a

3

1

1

在List系列中,还包含了Stack(栈)类和Vector(向量)类,Stack类除了实现List系列的功能以外,还实现了栈的结构,主要实现了出栈的pop方法和入栈的push方法。

而Vector类由于需要兼容老版本JDK中缘故,所以在实现的方法中需要提供老版本Vector类中对应的方法,这样导致Vector类中相同或类似的功能方法一般是成对出现的。
Set系列

Set系列中的类都实现了Set接口,该系列中的类均以Set作为类名的后缀。该系列中的容器类,不允许存储重复的元素。也就是当容器中已经存储一个相同的元素时,无法实现添加一个完全相同的元素,也无法将已有的元素修改成和其它元素相同。

  Set系列中类的这些特点,使得在某些特殊场合的使用比较适合。

该系列中常见的类有:

                   1、CopyOnWriteArraySet

                            以数组为基础实现的Set类。

                   2、HashSet

                            以哈希表为基础实现的Set类。

                   3、LinkedHashSet

                            以链表为基础实现的Set类。

                   4、TreeSet

                            以树为基础实现的Set类。

         以不同的数据结构类型实现的Set类,拥有不同数据结构带来的特性,在实际使用时,根据逻辑的需要选择合适的Set类进行使用。

         Set系列中的类的方法和List系列中的类的方法要比List系列中少很多,例如不支持插入和修改,而且对于Set系列中元素的遍历也需要转换为专门的Iterator(迭代器)对象才可以进行遍历,遍历时顺序和Set中存储的顺序会有所不同。

         下面是以HashSet类为基础实现的示例代码,代码如下:

 import java.util.*;

/**

 * 以HashSet为基础演示Set系列类的基本使用

 */

public class HashSetUse {

         public static void main(String[] args) {

                   //容器对象的初始化

                   Set set = new HashSet();         

                   //添加元素

                   set.add("1");

                   set.add("2");

                   set.add("3");

                   set.add("1");

                   set.add("1");                              

                   //删除数据

                   //set.remove("1");          

                   //遍历

                   Iterator iterator = set.iterator();

                   while(iterator.hasNext()){

                            System.out.println((String)iterator.next());

                   }

         }

}

该程序的运行结果为:

3

2

1
Map系列

  Map系列中的类都实现了Map接口,该系列中的部分类以Map作为类名的后缀。该系列容器类存储元素的方式和以上两种完全不同。

   Map提供了一种使用“名称:值”这样的名称和数值对存储数据的方法,在该存储方式中,名称不可以重复,而不同的名称中可以存储相同的数值。具体这种存储的格式将在示例代码中进行实现。

  在这种存储结构中,任何不为null的对象都可以作为一个名称(key)来作为存储的值(value)的标识,使用这种形式更利于存储比较零散的数据,也方便数据的查找和获得。Map类中存储的数据没有索引值,系统会以一定的形式索引存储的名称,从而提高读取数据时的速度。

         该系列中常见的类有:

                   1、HashMap

                            以Hash(哈希表)为基础实现的Map类。

                   2、LinkedHashMap

                            以链表和Hash(哈希表)为基础实现的Map类。

                   3、TreeMap

                            以树为基础实现的Map类。

         和上面的结构类似,以不同的数据结构实现的Map类,拥有不同数据结构的特点,在实际的项目中使用时,根据需要选择合适的即可。

         该系列的类中常见的方法如下:

                   a、get方法

                                     Object get(Object key)

                            该方法的作用是获得当前容器中名称为key的结构对应的值。

                   b、keySet方法

                                     Set keySet()

该方法的作用是返回当前容器中所有的名称,将所有的名称以Set的形式返回。使用这个方法可以实现对于Map中所有元素的遍历。

                   c、put方法

                                     Object put(Object key, Object value)

                            该方法的作用是将值value以名称key的形式存储到容器中。

                   d、putAll方法

                                     void putAll(Map t)

该方法的作用是将Map对象t中的所有数据按照原来的格式存储到当前容器类中,相当于合并两个Map容器对象。

                   e、remove方法

                                     Object remove(Object key)

                            该方法的作用是删除容器中名称为key的值。

                   f、size方法

                                     int size()

                            该方法的作用是返回当前日期中存储的名称:值数据的组数。

                   g、values方法

                                     Collection values()

该方法的作用是返回当前容器所有的值组成的集合,以Collection对象的形式返回。

         下面是一个简单的示例,在该示例中演示Map系列类的基本使用,代码如下:

import java.util.*;

/**

 * 以HashMap为基础演示Map系列中类的使用

 */

public class HashMapUse {

         public static void main(String[] args) {

                   //容器对象的初始化

                   Map map = new HashMap();           

                   //存储数据

                   map.put("苹果", "2.5");

                   map.put("桔子", "2.5");

                   map.put("香蕉", "3");

                   map.put("菠萝", "2");             

                   //删除元素

                   map.remove("桔子");              

                   //修改元素的值

                   map.put("菠萝", "5");             

                   //获得元素个数

                   int size = map.size();

                   System.out.println("个数是:" + size);          

                   //遍历Map

                   Set set = map.keySet();

                   Iterator iterator = set.iterator();

                   while(iterator.hasNext()){

                            //获得名称

                            String name = (String)iterator.next();

                            //获得数值

                            String value = (String)map.get(name);

                            //显示到控制台

                            System.out.println(name + ":" + value);

                   }

         }

}


该程序的运行结果为:

个数是:3

香蕉:3

菠萝:5

苹果:2.5
使用示例

         如前所述,集合框架中的类只是提供了一种数据存储的方式,在实际使用时,可以根据逻辑的需要选择合适的集合类进行使用。

         下面以一个字符串计算的示例演示集合类的实际使用。

         该程序的功能为计算一个数字字符串,例如”1+2*31-5”、”12*30/34-450”等,的计算结果,在该示例中支持四则运算,但是不支持括号。本示例中计算的字符串要求合法。

         该程序实现的原理是:首先按照运算符作为间隔,将字符串差分为数字字符串和运算符字符串的序列,由于分拆出的字符串数量不固定,所以存储到List系列的Vector容器中,然后按照运算符的优先级进行计算。

         该程序的代码如下:

import java.util.*;

/**

 * 计算字符串的值

 */

public class CalcStr {

         public static void main(String[] args) {

                   String s = "1+20*3/5";

                   double d = calc(s);

                   System.out.println(d);

         }       

         /**

          * 计算字符串的值

          * @param s 需要计算的字符串

          * @return 计算结果

          */

         public static double calc(String s){

                   //拆分字符串

                   Vector v = split(s);

                   //print(v); //测试代码

                   //计算字符串

                   double d = calcVector(v);

                   return d;

         }

        

         /**

          * 将字符串拆分为数字和运算符。

          * 例如:"1+23*4"则拆分为:"1"、"+"、"23"、"*"和"4"

          * @param s 需要拆分的字符串

          * @return 拆分以后的结果

          */

         private static Vector split(String s){

                   Vector v = new Vector();

                   String content = "";

                   int len = s.length(); //字符串长度

                   char c;

                   for(int i = 0;i < len;i++){

                            c = s.charAt(i);

                            //判断是否为运算符

                            if(c == '+' ||

                                     c == '-' ||

                                      c == '*' ||

                                      c == '/'){

                                     //存储数字

                                     v.add(content);

                                     //存储运算符

                                     v.add("" + c);

                                     //清除已有字符串

                                     content = "";

                            }else{

                                     content += c; //连接字符串

                            }

                   }

                   v.add(content); //添加最后一个数字

                   return v;

         }

        

         /**

          * 测试代码,输出拆分以后的结果

          * @param v 需要打印的Vector对象

          */

         private static void print(Vector v){

                   int size = v.size();

                   for(int i = 0;i < size;i++){

                            System.out.println((String)v.get(i));

                   }

         }

        

         /**

          * 计算Vector中的数据

          * @param v 存储拆分后字符串的Vector

          * @return 计算结果

          */

         private static double calcVector(Vector v){

                   int index1;

                   int index2;

                   //计算乘除

                   while(true){

                            index1 = v.indexOf("*"); //乘号索引值

                            index2 = v.indexOf("/"); //除号索引值

                            //无乘除符号

                            if(index1 == - 1 && index2 == -1){

                                     break; //结束循环

                            }                          

                            //如果有乘号

                            if(index1 != -1){

                                     //没有除号或乘号在前

                                     if(index2 == -1 || index1 < index2){

                                               String s1 = (String)v.get(index1 - 1); //第一个数字

                                               String opr = (String)v.get(index1); //运算符

                                               String s2 = (String)v.get(index1 + 1); //第二个数字

                                               //计算

                                               String answer = calc(s1,s2,opr);

                                               //计算以后的处理

                                               handle(answer,index1 - 1,v);

                                     }

                            }

                            //有除号

                            if(index2 != -1){

                                     //没有乘号或除号在前

                                     if(index1 == -1 || index2 < index1){

                                               String s1 = (String)v.get(index2 - 1); //第一个数字

                                               String opr = (String)v.get(index2); //运算符

                                               String s2 = (String)v.get(index2 + 1); //第二个数字

                                               //计算

                                               String answer = calc(s1,s2,opr);

                                               //计算以后的处理

                                               handle(answer,index2 - 1,v);

                                     }

                            }

                   }

                   //计算加

                   int index3 = v.indexOf("+");

                   while(index3 != -1){ //有加号

                            String s1 = (String)v.get(index3 - 1); //第一个数字

                            String opr = (String)v.get(index3); //运算符

                            String s2 = (String)v.get(index3 + 1); //第二个数字

                            //计算

                            String answer = calc(s1,s2,opr);

                            //计算以后的处理

                            handle(answer,index3 - 1,v);

                            //获得下一个加号的位置

                            index3 = v.indexOf("+");

                   }

                  

                   //计算减

                   index3 = v.indexOf("-");

                   while(index3 != -1){ //有加号

                            String s1 = (String)v.get(index3 - 1); //第一个数字

                            String opr = (String)v.get(index3); //运算符

                            String s2 = (String)v.get(index3 + 1); //第二个数字

                            //计算

                            String answer = calc(s1,s2,opr);

                            //计算以后的处理

                            handle(answer,index3 - 1,v);

                            //获得下一个减号的位置

                            index3 = v.indexOf("-");

                   }

                   //反馈结果

                   String data = (String)v.get(0);

                   return Double.parseDouble(data);

         }

        

         /**

          * 计算两个字符串类型的值运算结果

          * @param number1 数字1

          * @param number2 数字2

          * @param opr 运算符

          * @return 运算结果

          */

         private static String calc(String number1,String number2,String opr){

                   //将字符串转换为数字

                   double d1 = Double.parseDouble(number1);

                   double d2 = Double.parseDouble(number2);

                   //判断运算符

                   if(opr.equals("+")){

                            return "" + (d1 + d2);

                   }

                   if(opr.equals("-")){

                            return "" + (d1 - d2);

                   }

                   if(opr.equals("*")){

                            return "" + (d1 * d2);

                   }

                   if(opr.equals("/")){

                            return "" + (d1 / d2);

                   }

                   return "0"; //运算符错误时返回0

         }

        

         /**

          * 计算以后的处理

          * @param answer 计算结果

          * @param index 参与计算的三个字符串中第一个字符串的起始位置

          * @param v 存储字符串的容器

          */

         private static void handle(String answer,int index,Vector v){

                   //删除计算过的字符串

                   for(int i = 0;i < 3;i++){

                            v.remove(index);

                   }

                   //将计算结果插入到index位置

                   v.insertElementAt(answer, index);

         }

}


该程序的运行结果为:
13.0


文章出处:http://www.cnblogs.com/springcsc/archive/2009/12/03/1616357.html
分享到:
评论

相关推荐

    java集合类详解(set list ArrayList等java集合类详述)

    Java 集合类详解 Java 集合类是 Java 语言中的一种基本数据结构,用于存储和操作大量数据。集合类可以分为三大类:Collection、List 和 Set。 Collection 是集合框架中的根接口,提供了基本的集合操作,如 add、...

    java集合类线程安全.doc

    所涉及的集合类不仅包括 Java SE 1.2 引入的集合类,还包括旧集合类(Java SE 1.2 前引入)和新集合类(Java SE 5 引入)。 Java 线程安全的等级定义根据 Bloch 的定义,将线程安全分为五个等级: 1. 非可变:如果...

    Java集合排序及java集合类详解.pdf

    Java集合排序及java集合类详解.pdf

    Java 集合排序及java 集合类详解

    Java 集合排序及java 集合类详解 Java 集合排序及java 集合类详解,Java里面最重要、最常用也就是集合那部分了,能够用好集合和理解好集合对于做Java程序的开发拥有无比的好处。本教程详细解释了关于Java中的集合是...

    第13讲 JAVA集合类.ppt

    Java集合类是Java编程语言中用于存储和管理对象的关键组件,它们构成了Java Collections Framework的核心。这个框架提供了一组高效、灵活的数据结构,使得开发者能够轻松地处理数据集合,而无需关心底层实现的复杂性...

    java集合类详解

    Java集合类是Java语言中用来存储数据的结构,它们是Java开发中非常重要的组件。在Java 2平台之前,集合框架的组成较为零散,自Java 2平台的JDK 1.2版本之后,引入了集合框架(Collections Framework),为集合类提供...

    java自定义集合类

    自定义集合类则是开发者根据特定需求扩展Java集合框架的行为,以满足个性化或特定业务场景的功能需求。以下是对"java自定义集合类"这一主题的详细解释。 首先,Java集合框架包括接口(如List、Set、Map)和实现这些...

    Java集合排序及java集合类详解

    在本篇中,我们将深入探讨Java集合的排序机制以及集合类的详细使用。 首先,我们来了解一下Java集合的基本分类。Java集合主要分为两大类:List(列表)和Set(集)。List是一个有序的集合,允许元素重复,并且可以...

    一张图让你看清Java集合类

    一张图让你看清Java集合类 所有精华 集于一图 一目了然 形象易懂 十分中肯 绝对干货!

    Java集合类图片

    Java集合类,在图片上体现出来,为了更好的描述,本来是博客里的,不好往博客里插,所以单独弄出来了。

    java集合类演示源码

    集合类的框架为集合的实现者提供了大量的接口和抽象类,并对其中的某些机制给予了描述,例如,Iterator(迭代协议)。实现Comparable接口或Comparator接口,用户可以根据需要对集合中的元素进行排序。为了方便用户...

    Java集合详解,详细讲解java的集合类

    本文将深入讲解Java集合类,特别是Collection接口和其下的List、Set,以及Map接口中的几个重要实现类。 首先,我们来看Collection接口。Collection是最基本的集合接口,它代表一组Object,即它的元素。Collection...

    java集合类总结

    本文将对Java集合框架中的Collection接口及其相关接口、类进行深入的探讨。 首先,Collection接口是所有单值容器的基础,它是Set、List和Queue接口的父接口。Collection接口定义了通用的操作方法,如`add()`用于...

    Java集合类性能分析

    ### Java集合类性能分析 #### 一、Java集合框架概览 Java集合框架是一个非常重要的概念,它提供了处理数据集合的标准方法。集合框架的核心部分主要包括集合接口、抽象类以及具体的实现类。 - **集合接口**:Java...

    java 集合类 容器类

    ### Java集合类与容器类详解 #### 一、引言 在Java编程中,集合类是一种非常重要的数据结构,用于存储一系列对象。相比于数组,集合类提供了更多的灵活性和功能,尤其是在处理未知数量的对象时更为方便。Java标准...

    java集合类面试题总结

    Java 集合类面试题总结 Java 集合类是 Java 语言中的一种重要组件,用于存储和操作数据。下面总结了 Java 集合类的一些常见问题和答案。 HashMap 和 Hashtable 的区别 HashMap 和 Hashtable 都是 Java 中的散列表...

    Java集合类矩阵图

    Java集合类矩阵图是Java编程中非常重要的一个概念,它主要涵盖了Java集合框架中的各种接口、类以及它们之间的关系。这个矩阵图可以帮助开发者更清晰地理解Java集合框架的层次结构和实现方式。在这个矩阵图中,你可以...

    java常用集合类总结

    "Java集合类总结" Java集合类是Java语言中的一种重要数据结构,用于存储和管理数据。Java集合类可以分为两种:Collection接口和Map接口。Collection接口有两个子接口:List接口和Set接口。List接口是有序的,可以...

Global site tag (gtag.js) - Google Analytics