码迷,mamicode.com
首页 > 编程语言 > 详细

Java的集合框架

时间:2017-10-27 01:37:57      阅读:223      评论:0      收藏:0      [点我收藏+]

标签:结束   安全   value   override   需要   方式   生活   编码   tco   

Java集合框架综述

1:集合框架(Collection Framework)

首先要知道 集合代表的是一组对象,和数组差不多 但是数组的长度是固定不变的,而集合是可以变换长度的,比如说:集合就是一根金箍棒,可长可短, 数组就像是一根普通的木棍,长度是固定的,不能变长或者变短。在Java的集合框架中定义了一套规范用来操作集合和具体实现细节,在这里呢也可以把集合想象成一个数据库 ,它有“增删改查”四种操作 ,在本章呢会介绍集合框架的基本类和接口和一些的基本操作方法。

2:集合框架的两大接口(Collection和Map)

1.Collection接口

Collection表示一组对象 ,这些对象也称为collection元素,一个collection允许有重复的值,而另一些则不允许,一些collection是有序的,而有一些是无序的,在Java中没有直接实现collection的 但是它提供了两个子接口 这两个子接口继承了collection接口,那是哪两个接口呢?

ヾ(??▽?)ノ  这里介绍两个collection接口的子接口    List   和   Set  

 

1.1ArraysLIst类

ArrayList是List的一个实现类。每一个ArrayList实例都有一个容量,该容量是指用来存储列表的数组大小,它总是等于或者小于列表的大小,随着向ArrayList不断添加元素,其容量也不断的增大。这里ArrayList它跟数组有很多相同点,到底有什么相同点和不同点呢?如下技术分享

那知道ArrayList的概念 怎么创建一个ArrayList集合呢?  定义语法如下:

 1 //创建ArrayList集合 2 List list = new ArraysList(0); 

 在创建ArrayList集合的时候需要导入包:

//导入包
import
java.util.ArrayList; import java.util.List;

知道了创建ArrayList集合 那怎么向集合里添加元素呢  开始说过java集合框架中定义了一套规范来实现“增伤改查”那怎么实现具体操作呢?下面介绍ArrayList集合的常用方法:

ArraysLIst 集合的常用方法
Arrays.asList(); 将数组装换为集合 
add(Object value); 添加元素
add(int index,Object value)向指定位置插入元素 
get(int index);通过下标获取元素 
set(intindex,Object value);修改指定位置的元素 
remove(int index); 移除集合中指定位置的元素
remove(Object o);从集合中移除第一次出现的指定元素(如果存在) 
removeAll(collection<?>c);从列表中移除制动的collection 中包含的所有元素
Clear (); 移除集合中所有的元素
//遍历ArrayList
foreach(Object item : list){
    //通过get()方法获取元素
}

需要注意的是: 1.存储的元素类型都是Object类型

        2.ArrayList集合中是可以添加重复的值,这个跟数组是一样的

                          3. 它的初始容量为10的空列表

1.2HashSet类

 HashSet是一个哈希集是set的一个重要实现类 它不保证顺序恒久不变,也就是说是无序的,它允许使用NUll元素  但是只能有一个。而且他还不能有重复的值。set中 添加某个对象 无论添加多少次  最终只会保留一个该对象(的引用) 并且 保留的是第一次添加的那一个。既然是无序的所以它没有索引,不能通过索引获取元素。同样跟ArrayList一样它储存的类型也是Object类型。

那怎么创建一个Hashset呢?  代码如下:

//创建HashSet(哈希集)
HashSet hashset= new HashSet();

在创建HashSet实例时需要导入包:

import java.util.HashSet;

 

以下是HashSet类的一些常用方法   如下图:

add(Object value) 如果此 set中尚未包含指定元素,则添加指定元素 它的返回值是Boolean类型

clear() 移除所有元素

remove(Object o)如果指定元素存在于此 set 中,则将其移除 它的返回值是Boolean类型

size()获取set中的元素的数量  返回值是int

isEmpty()判断该set中是否包含任何元素 返回值是boolean类型

iterator() 返回对此 set 中元素进行迭代的迭代器。

大家看到Hashset并没有直接获取元素的方法,因为他是无序的 没有索引,这里我们用iterator()方法迭代获取数据,那怎么用呢?代码如下:

 

import java.util.Iterator;//导包

itIterator i = hash.iterator(); while(i.hasNext()){ String str = (String)i.next();//需要强转 }

这里需要注意的是  HashSet里储存是Object类型  需要什么数据类型 就强转成什么数据类型

上面的是通过Iterator()方法进行迭代  看起来比较麻烦  所以还有一种渐变的方法  通过foreach迭代器进行获取数据 代码如下:

foreach(Object item in hash){

      //获取数据        

}

 上面是Collection接口中的两个子接口 List和Set 下面介绍另一个接口  Map

2.Map接口

 

Map提供了一种映射关系 其中的元素是以键值对(Key-value)的形式存储的 能够实现根据key快速查找Value

Map中的键值对以Entry类型的对象实例形式存在

健(key值)不可重复 value值可以
一个值可以跟很多的key进行映射关系 但一个健(key值)最多只能映射到一个值(value)

 2.1 HashMap类

 HashMap是map的一个重要实现,也是最常用的 基于哈希表实现 它的Entry对象是无序排序的,Key值和value值都可以为null 但是一个HashMap只能有一个kay值为null的映射(key值不可重复)

介绍了HashMap类的概念 那怎么创建呢?  代码如下:

//导入包
import java.util.HashMap;
//创建Hashmap
HashMap hash = new HashMap();

那HashMap类中有什么常用方法呢?如下:

get(Object key); 指定健获取所映射的值
Clear();从此映射中移除所有的映射关系
remove(Object key);从此映射中移除指定键的映射关系(如果存在)
size();  获取此映射中的键-值映射的关系
put(K key,V value) 在此映射中关联指定的值与指定键  如果该映射以前包含了一个该键的映射关系  从而达到修改的功能
entrySet 语法: public Set<Map.Entry<K,V>> enttryset()  返回map中所有的键值对
KeySet  语法: public Ste<k>keyset()  返回此映射中所包含的键的set视图
getKey()  获取键 
getValue() 获取值

如何向HashMap中添加映射关系呢?如下:

//创建HashMap
HashMap hashmap =  new HashMap();
//通过HashMap类的Put()方法添加映射关系
hashmap.put(1, "张三");

这里需要注意的是:1.向HashMap中添加映射关系时  需要指定一个Key(键)指定一个Value(值)从而达到映射关系,

                                 2.同样这里的健(key)和值(value)都是object类型,

如何获取HashMao中的数据呢?HashMap是键值对可以通过获取键的方法获取数据代码如下:

//通过HashMap类的gat(object key)获取值
System.out.println(hashmap.get(1));

那如何遍历HashMap中的元素呢? 用foreach迭代器实现 代码如下:

//遍历HashMap的Key值获取数据
for (Object item:hashmap.keySet()) {
    System.out.println(hashmap.get(item));
            
}

其他的方法就不一一测试了  ( ̄▽ ̄)~* 

那现在有一个问题 比如如下代码:

List list = new ArrayList();
list.add("qqyumidi");
list.add("corn");
list.add(100);
 for (int i = 0; i < list.size(); i++) {
       String name = (String) list.get(i); //1
       System.out.println("name:" + name);
}

定义了一个List类型的集合,先向其中加入了两个字符串类型的值,随后加入一个Integer类型的值。这是完全允许的,因为此时list默认的类型为Object类型。在之后的循环中,由于忘记了之前在list中也加入了Integer类型的值或其他编码原因,很容易出现类似于//1中的错误。因为编译阶段正常,而运行时会出现“java.lang.ClassCastException”异常。因此,导致此类错误编码过程中不易发现。

以上代码中有两个问题:

A.当我们将一个对象放入集合中,集合不会记住此对象的类型,当再次从集合中取出此对象时,改对象的编译类型变成了Object类型,但其运行时类型任然为其本身类型。

B.因此,//1处取出集合元素时需要人为的强制类型转化到具体的目标类型,且很容易出现“java.lang.ClassCastException”异常。

那有什么办法可以使集合能够约束元素类型呢 并达到安逸不报错呢?在Collection和Map中有出现了一个泛型集合。

3.什么是泛型?

泛型也可以理解为“参数化类型”,类型的参数化,就是可以把类型像方法的参数那样传递。这一点意义非凡。

那它有什么作用呢? :泛型使编译器可以在编译期间对类型进行检查以提高类型安全,减少运行时由于对象类型不匹配引发的异常。

怎么定义个泛型集合呢?把上面的代码修改如下:

List<String> list = new ArraysList<String>();//定义泛型的语法 

list.add("aaa");

list.add("bbb");

list.add(1111);//1

foreach(String item : list){

   System.out.println(item);    

}

根据上面的代码 得到 定义泛型集合的语法:

List<E> list  = new ArraysList<E>();
在List<>尖括号里是要对集合数据类型的约束
<E>中的E表示类型形参,可以接收具体的类型实参
上面的代码集合类型是String类型 那么代码“1”我们添加一个int类型的数据 这样编译器是会报错的,因为在定义泛型的时候 限制的是String类型 所以只能添加String类型的数据,
所以我们总结: 当泛型进行了数据类型约束的时候 不能添加其他的数据类型,否则编译器会报错。
那么HashSet也可以定义泛型,对元素的数据类型进行约束,那怎么创建HashSet泛型呢?语法如下:
//创建HashSet泛型
HashSet<E> hashSet = new HashSet<E>();

同样是对HashSet中的元素进行数据类型约束 用法如上,具体方法 请往上看HashSet集合的方法。

需要注意的是:

                 1.泛型集合中 不能添加泛型规定的类型及其子类型以外的对象 否则会报错
                 2.泛型集合中的限定类型 不能使用基本数据类型
                 3. 可以通过使用包装类限定允许存入的基本数据类型

以上是Collection家族的集合和泛型,那么Map家族有泛型吗?  答案是肯定的  

HashMap如何定义泛型呢  我们用代码实现一下  代码如下:

//定义HashMap泛型
HashMap<K, V> Hashmap = new HashMap<K, V>();

在HashMap<K,V>

K代表的是Key(键)的数据类型,

V代表的值(value)的数据类型,

也就是说 K键的数据类型必须是规定的数据类型不能是其他的数据类型,值(value)也是一样。

以上是对泛型的介绍,这里在介绍一下Map中的contains方法:

contains方法 某个序列是否包含某个对象  如果包含则返回true  如果不包含则返回faslse

HashMap中:

ContainsKey(object key); 获取此映射是否包含对于指定建的映射关系
ContainsValue(object values); 获取此映射是否在此映射中存在的值

具体怎么使用呢?请看代码:

Student类

public class Student {
    //学号
    private String id;
    
    //姓名
    private String name;
    
    
    public String getId() {
        return id;
    }


    public void setId(String id) {
        this.id = id;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }

    public Student(String id,String name){
        
        this.id=id;
        this.name=name;
        
    }
    

}

 

test类

import java.util.HashMap;
/**
 * ClassName: TestContains 
 * @Description: TODO测试 Map接口的HashMap类的Contains方法
*/
public class TestContains {
    
    public static void main(String[] args) {
        
        //创建HashMap泛型   键的类型约束是String类型 值的类型约束是学生类(Student)
        HashMap<String, Student> hashmap  = new HashMap<String, Student>();
        //创建一个学生 张三
        Student zs = new Student("A1000", "张三");
        //向泛型中添加元素
        hashmap.put("1",zs);
        //检查是否存在键Key 1
        boolean yesno = hashmap.containsKey("1");
        //输出结果
        System.out.println("Does it contain key1:"+yesno);
        //检查是否包含值 Value “张三”这个学生
        boolean yesno1 = hashmap.containsValue(zs);
        //输出结果
        System.out.println("Does it contain values‘张三’:"+yesno1);
        
    }
}

这里我的HashMap中key的约束数据类型是String (这里大家注意下 泛型类型约束不能放基本数据类型 可以放数据类型的类 )value的类型约束是Student类的实例,也是就是说我定义的是学生类  里面只能放一个学生 要是放一个老师就不行。

言归正传 这里我使用HashMap中的Contains方法来判断泛型中是否包含某个键 或者包含某个对象,它的返回值类型就是Boolean类型,true或false;

接下来带大家认识两个接口和一个工具类:

1.Collections(工具类)

Collections工具类是java集合框架中 用来操作集合对象的工具类,这里我们只介绍一个方法sort();

在使用之前需要导入工具类的包 代码如下:

 

//导入包
import java.util.Collections;

 

sort()方法呢主要是排序 语法如下:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class TetsCollectionsSort {
    public static void main(String[] args) {
        
        //创建ArrayList泛型
        List<String> list = new ArrayList<String>();
        //向集合里添加数据
        list.add("aasd");
        list.add("csfgsfd");
        list.add("zasd");
        list.add("gghg");
        //输出排序前
        System.out.println("排序前");
        for (String item : list) {
            System.out.println(item);
        }
        //进行排序
        Collections.sort(list);
        //排序后
        System.out.println("排序后");
        for (String item : list) {
            
            System.out.println(item);
            
        }
    }
}
这里发现这些字符串的顺序发生了变化 那么是怎么进行排序的呢?
答:
在排序String字符串的时候是比较首字母排序   如果首字母一样则比较第二个字符  如此往下,如果字符串的开头是数字,则比较数字的大小,数字在前,字母在后,
上面是java集合框架的Collections工具类的sort()方法的介绍,下面介绍一个接口
2.Comparable接口
前面介绍了Collections.sort()方法   而要实现序列的排序就要实现comparable接口下面就介绍Comparable接口
实现该接口表示,这个类的实例可以进行自然排序,
定义了默认的比较规则
其实现类需要compareTo()方法
compareTo
()方法返回整数表示大 负数表示小 0表示相等
一个生活的小案例 在学校里做广播体操时 一般学生的排列都是按照身高去排列,从矮到高排列 因此学生是可以进行比较的,那么我们想两个事物要进行比较,是不是要找到可以比较的方式呢?在我们比较连个事物的时候
会有一个默认的比较规则,称为自然排序,比如在学生排列的时候这个身高就是可以比较的特性,也是默认的比较规则,那么自然顺序就是身高之间的差异。
那么如何用代码实现呢? 代码如下:
Student类
public class Student{
    //学号
    private String id;
    
    //姓名
    private String name;
    
    
    public String getId() {
        return id;
    }


    public void setId(String id) {
        this.id = id;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }

    public Student(String id,String name){
        
        this.id=id;
        this.name=name;
        
    }
}
test类
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;

/* ClassName: TestContains 
 * @Description: TODO测试comparable接口比较对象
 */
public class TestContains {

    public static void main(String[] args) {

        // 创建HashMap泛型 键的类型约束是String类型 值的类型约束是学生类(Student)
        List<Student> list = new ArrayList<Student>();
        // 创建两个学生 张三 李四
        Student zs = new Student("Z1000", "张三");
        Student ls = new Student("V1000", "李四");
        // 向集合中添加元素
        list.add(zs);
        list.add(ls);
        // 排列前
        for (Student item : list) {
            System.out.println("学号是:" + item.getId() + "姓名:" + item.getName());
        }
        // 排列
        Collections.sort(list);//1
        // 排序后
        for (Student item : list) {
            System.out.println("学号是:" + item.getId() + "姓名:" + item.getName());
        }

    }
}

这里呢我们的代码1处会报错的  是因为咱们的Student这个类没有实现comparable接口  所以我们要对Student这个类进行改造 修改后的代码如下:

public class Student  implements Comparable<Student>{
    //学号
    private String id;
    
    //姓名
    private String name;
    
    
    public String getId() {
        return id;
    }


    public void setId(String id) {
        this.id = id;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }

    public Student(String id,String name){
        
        this.id=id;
        this.name=name;
        
    }

  //重写comparable的comparato()方法
    @Override
    public int compareTo(Student o) {
        
        return this.id.compareTo(o.id);
    }
    

}

这里让Student这个类实现Comparable接口  因为接口都是抽象的 所以这里必须重写compareTo()方法  

这个方法实现  让学生的Id进行一个比较排列 返回整形  那么Test类输出如下:

排序前
学号是:Z1000姓名:张三
学号是:V1000姓名:李四
排序后
学号是:V1000姓名:李四
学号是:Z1000姓名:张三

这里的排序方法向上面介Collections.sort()方法一样

3.Comparator接口 ---- 比较工具
用于定义临时比较规则,而不是默认比较规则
其实现类需要实现Compare()方法
强行对某个对象 collection 进行整体排序 的比较函数。可以将 Comparator 传递给 sort 方法
compare()方法返回整数表示大 负数表示小 0表示相等

具体实现comparator接口的代码如下:
StudentComparator类
import java.util.Comparator;

public class StudentComparator implements Comparator<Student>{

  //要实现Comparator接口必须要重写Compare()方法 @Override
public int compare(Student o1, Student o2) { //按照学生的姓名进行排列 return o1.getName().compareTo(o2.getName()); } }
Test类修改如下:
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;

/* ClassName: TestContains 
 * @Description: TODO测试comparable接口比较对象和comparator接口
 */
public class TestContains {

    public static void main(String[] args) {

        // 创建HashMap泛型 键的类型约束是String类型 值的类型约束是学生类(Student)
        List<Student> list = new ArrayList<Student>();
        // 创建两个学生 张三 李四
        Student zs = new Student("Z1000", "张三");
        Student ls = new Student("V1000", "李四");
        // 向集合中添加元素
        list.add(zs);
        list.add(ls);
        // 排列前
        System.out.println("排序前");
        for (Student item : list) {
            System.out.println("学号是:" + item.getId() + "姓名:" + item.getName());
        }
        // 排列
        Collections.sort(list);
        // 排序后
        System.out.println("排序后");
        for (Student item : list) {
            System.out.println("学号是:" + item.getId() + "姓名:" + item.getName());
        }
        //按照姓名排序如下
        System.out.println("按照姓名排序是:");
        Collections.sort(list,new StudentComparator());
        for (Student item : list) {
            System.out.println("学号是:" + item.getId() + "姓名:" + item.getName());
        }
        
    }
}

这里Collections.sort();时需要传递一个集合  和一个实现类的对象,

本章主要介绍Java集合框架的主要成员有:Collection接口  Map接口 Collections工具类  Comparable接口 Comparator接口

 

本章内容到此结束!!!

 




 

Java的集合框架

标签:结束   安全   value   override   需要   方式   生活   编码   tco   

原文地址:http://www.cnblogs.com/zkdayup/p/7737529.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!