JAVA中的集合

JAVA中集合，是java中的基础概念，今天接着跟讲课准备课件的机会，重新整理一下关于JAVA中的集合的概念。

集合的概念

• java中的集合类是用来存放对象的
• 集合相当于一个容器，里面包容着一组对象--容器类
• 其中的每个对象作为集合的一个元素出现
• java API提供的集合类位于java.util包中

java中集合和数组的比较

• 数组也是容器，它是定长，访问较快，但是数组不会自动扩充
• 数组可以包含基本数据类型或者是引用类型的对象，而集合中只能包含引用类型的对象

为了容纳一组对象，最适宜的选择应当是数组。而且假如容纳的是一系列基本数据类型，更是必须采用数组。当我们编写程序 时，通常并不能确切地知道最终需要多少个对象。有些时候甚至 想用更复杂的方式来保存对象。为解决这个问题，Java提供了集合框架。

集合的特点：

• • 用于存储对象的容器。
  • 集合长度是可变的
  • 集合中不可以存储基本数据类型值，只能存储对象

集合的学习目标

（1）集合本身是一个存储的容器

（2）必须使用集合存储对象

（3）遍历集合,取出对象

（4）集合体系中有很多的集合，每个集合都有自己的特性，要知道每个集合有什么特点。

集合类型主要有3种：set(集）、list(列表）和map(映射)。

JAVA中的集合框架

集合容器因为内部的数据结构不同，有多种具体容器。 不断的向上抽取，就形成了集合框架。

 

Collection接口

我们先来看集合体系中最顶层的接口  Collection接口

        Collection是层次结构中的根接口，Collection表示一组对象，这些对象也称为Collection中的元素，一些collection允许有重复的元素，如List，而有一些是不允许有重复元素 ，一些事有序的，一些是无序的，List派系的集合就是有序的，而Set接口集合里面的是无序的。

我们先学习他们共性的东西，Collection接口

Collection的功能由它实现类决定

• • • • 1. List允许重复,有序(先添加在前,后添加的元素位置在后)
      • 2. Set不允许重复,无序(跟添加的先后无关，只跟元素本身的hashCode值)

Collection接口中的方法，这些方法是集合中所有实现类必须拥有的方法 Collection接口中的方法都是抽象方法，所以使用Collection接口的实现类 例如：ArrayList implements List List extends Collection 方法的执行,都是实现的重写

• • add(); 向集合添加数据
  • toArray();集合中的元素,转成一个数组中的元素, 集合转成数组
  • clear(); 清空集合中的所有的元素
  • remove(); boolean remove(Object o)移除集合中指定的元素
  • contains(Object obj); 判断对象是否是存在集合中，对象存在返回true size();

我们通过一个简单的例子来演示一下方法的具体的使用

//toArray()方法和clear()方法

private static void function() {
		Collection<String> coll = new ArrayList<String>();
		coll.add("abc");
		coll.add("def");
		coll.add("ghi");
		coll.add("gkl");
		coll.add("mno");
		
		Object[] objs = coll.toArray();
		for(int i = 0 ; i < objs.length ; i++){
			System.out.println(objs[i]);
		}
	}
	 * void clear() 清空集合中的所有元素
	public static void function(){
		Collection<String> coll = new ArrayList<String>();
		coll.add("abc");
		coll.add("bcd");
		System.out.println(coll);	
		coll.clear();	
		System.out.println(coll);
	}

Iterator迭代器

在Java中，有很多的数据容器，对于这些的操作有很多的共性。Java采用了迭代器来为各种容器提供了公共的操作接口。这样使得对容器的遍历操作与其具体的底层实现相隔离，达到解耦的效果。使用迭代器我们可以很方便的对集合的元素进行遍历，一次取出集合中的元素。

我们通过查看API可以发现，Iterator中定义了三个方法

我们通过一个例子来演示Iteraror的使用方法

public class IteratorDemo {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<String>();
        coll.add("abc1");
        coll.add("abc2");
        coll.add("abc3");
        coll.add("abc4");
        //迭代器,对集合ArrayList中的元素进行取出
        
            //调用集合的方法iterator()获取出,Iterator接口的实现类的对象
        Iterator<String> it = coll.iterator();    
            //接口实现类对象,调用方法hasNext()判断集合中是否有元素
        boolean b = it.hasNext();        
        System.out.println(b);
        //接口的实现类对象,调用方法next()取出集合中的元素
        String s = it.next();
        System.out.println(s);        
        //迭代是反复内容,使用循环实现,循环的条件,集合中没元素, hasNext()返回了false
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }    
       
    }
}

在Iterator中主要是使用一个面向接口编程的思想

Iterator  是一个接口，我们要找他的实现类。Collection中定义了一个方法Iterator  iterator()方法，在使用的时候ArrayList会重写方法iterator()返回了Iterator接口的实现类的对象。使用ArrayList集合的对象， Iterator it = array.iterator(),运行结果就是Iterator接口的实现类的对象。it是接口的实现类对象,调用方法 hasNext 和 next 集合元素迭代

增强for循环

这里介绍的增强for循环也是一种遍历集合的方式

jdk1.5出现的新特性---->增强for循环 ，JDK1.5版本后,出现新的接口 java.lang.Iterable，Collection开是继承Iterable，Iterable作用,实现增强for循环

增强for循环的作用：

简化迭代器的书写格式。(注意：增强for循环的底层还是使用了迭代器遍历。)

增强for循环的适用范围： 如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。

增强for循环的格式： for(数据类型 变量名 :数组或集合) { //数据类型 变量名:声明一个变量用来接收遍历目标遍历后的元素}

我们也通过一个例子，来具体的演示一下

 *  实现for循环,遍历数组
    public static void function(){
        int[] arr = {4,2,9,0};
        for(int i : arr){
            System.out.println(i);
        }
        System.out.println(arr[0]);   
    }
public static void function_2(){
        ArrayList<Person> array = new ArrayList<Person>();
        array.add(new Person("a",20));
        array.add(new Person("b",10));
        for(Person p : array){
            System.out.println(p);    打印P就是打印P中的toString()方法，如果没有tostring  就是直接打印的是地址
        }
    }

• 好处: 代码少了,方便对容器遍历 弊端: 没有索引,不能操作容器里面的元素，因为东数组是需要索引的，所以不能用折半查找，排序就不行了

 List接口

我们通过集合体系框架图可以发现，List是Collection下的接口，和Collection是继承关系。List下主要有两个实现类，ArrayList、和LinkedList

 

 

List接口中的抽象方法,有一部分方法和他的父接口Collection是一样

List接口的自己特有的方法, 带有索引的功能

• • add(int index,E) 将元素插入到列表的指定索引上
  • E remove(int index) 移除指定索引上的元素,返回被删除之前的元 素
  • E set(int index, E) 修改指定索引上的元素,返回被修改之前的元素

我们通过一个案例来具体的演示一下List的使用方式。

指定索引添加元素
public static void function(){
        List<String> list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        System.out.println(list); 
        list.add(1, "zzu");
        System.out.println(list);
    }

移除索引上的元素
    public static void function_1(){
        List<Double> list = new ArrayList<Double>();
        list.add(1.1);
        list.add(1.2);
        list.add(1.3);
        list.add(1.4);
        
        Double d = list.remove(0);
        System.out.println(d);
        System.out.println(list);
    }
修改索引上的元素
    public static void function_2(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Integer i = list.set(0, 5);
        System.out.println(i);
        System.out.println(list);
    }

 

Set（集）接口

Set是最简单的集合，集合中的对象不按照特定的方式排序，并且没有重复的对象。

Set接口主要有两个实现类：HashSet和TreeSet。

Set集合是没有索引的，set集合取出元素的方式可以采用：迭代器、增强for循环。

• • Set集合中存放的是对象，并且没有重复对象。
  • Set接口的实现类，HashSet（哈希表）
  • 特点：无序集合,存储和取出的顺序不同,没有索引,不存储重复元素
  • 代码：代码的编写上,和ArrayList完全一致

hashSet

HashSet类按照哈希算法来存取集合中的对象， 具有很好的存取和查找性能。

底层数据结构：哈希表

■当向集合中加入一个对象时，HashSet会调用 对象的hashCode()方法来获得哈希码，然后根据哈希码进一步计算出对象在集合中的位置。

 底层原理：

 

我们通过一个简单的例子来演示一下使用方法

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("cn");
        set.add("zzu");
        set.add("java");
        set.add("java");
        set.add("computer");
        
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("======================");
        
        for(String s : set){
            System.out.println(s);
        }
    }
}

HashSet不能存放重复元素
public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        set.add(new String("abc"));
        set.add(new String("abc"));
        set.add(new String("bbc"));
        set.add(new String("bbc"));
        System.out.println(set);
    }

Map(键值对映射)

 Map(映射集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。

Map集合中，元素是成对存在的，每个元素都由健与值两部分组成，通过健可以找到所对应的值。

向Map集合中加入元素时，必须提供一对键对象和值对象。

　　Map中常用的集合为HashMap集合，LinkedHashMap集合

• 使用Map接口的实现类 HashMap V put(K,V) K 作为键的对象, V作为值的对象，返回值为V

public static void function(){
//创建集合对象,HashMap,存储对象,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 1);
        map.put("b", 2);    
        map.put("c", 3);    
        System.out.println(map);
}

使用Map接口的实现类 HashMap V get(K) ，如果集合中没有这个键,返回null

public static void function(){
//创建集合对象,HashMap,存储对象,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 1);
        map.put("b", 2);    
        map.put("c", 3);    
        System.out.println(map);
}

Map集合的遍历

Map集合的遍历：利用键获取值，Map接口中定义方法keySet，取出所有的键,存储到Set集合

• • 1.调用map集合的方法keySet,所有的键存储到Set集合中， Map集合不能直接遍历，必须借助一个第三方的集 合Set，先存储健
  • 2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
  • 3. 调用map集合方法get,通过键获取到值 程序演示

public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("a", 11);
        map.put("b", 12);
        map.put("c", 13);
        map.put("d", 14);
        
        //1. 调用map集合的方法keySet,所有的键存储到Set集合中
        Set<String> set = map.keySet();
        //2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            //it.next返回是Set集合元素,也就是Map中的键
            //3. 调用map集合方法get,通过键获取到值
            String key = it.next();
            Integer value = map.get(key);
            System.out.println(key+"...."+value);
        }
使用增强for循环进行遍历，增强for不能遍历Map  但是可以遍历set集合，取值
        System.out.println("=======================");

        for(String key : map.keySet()){
            Integer value = map.get(key);
            System.out.println(key+"...."+value);
        }
    }

Entry键值对对象

在Map类设计的时候，提供了一个嵌套接口：Entry。

Entry将健值对的对应关系封装成了对象，即键值对对象，这样我们在遍历Map集合时，就可以从每一个健值对Entry对象中获取对应的健与对应的值。

Map集合获取方式--entrySet方法,键值对映射关系获取

实现步骤:

• • 1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合 Set<Entry <K,V> >
  • 2. 迭代Set集合
  • 3. 获取出的Set集合的元素,是映射关系对象
  • 4. 通过映射关系对象方法 getKet, getValue获取键值对

public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "abc");
        map.put(2, "bcd");
        map.put(3, "cde");
        //1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
        Set<Map.Entry <Integer,String> >  set = map.entrySet();
        //2. 迭代Set集合
        Iterator<Map.Entry <Integer,String> > it = set.iterator();
        while(it.hasNext()){
            //  3. 获取出的Set集合的元素,是映射关系对象
            Map.Entry<Integer, String> entry = it.next();
            //4. 通过映射关系对象方法 getKet, getValue获取键值对
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"...."+value);
        }
        
        System.out.println("=========================");
        for(Map.Entry<Integer, String> entry : map.entrySet()){
            System.out.println(entry.getKey()+"..."+entry.getValue());
        }
    }

本文主要是简单的介绍一下集合中部分的方法的使用，以及一些实现类的使用。是对平时学习集合这一章节的总结，如有写错欢迎大家批评指正。