集合框架

集合框架是为表示和操作集合而规定的一种统一的标准系结构
集合框架都包含三大块内容:对外的接口,接口的实现,集合运算的算法

1>接口:表示集合的抽象数据类型

2>实现:集合框架中的具体实现

3>在一个实现了某个集合框架的接口的对象身上完成某种有用的计算的方法

那什么时候用集合呢?

1.在对象多的时候 , 先进行存储

2.数组满足不了要求时,因为数组长度是固定的,所有添加内容会显得有些累赘,所以集合就是一个很好的选择

Java集合框架中的两大集合类接口 : Collection 和 Map

Collection 又有两个子接口 : List 和 Set 所以通常说Java集合框架一共有三大类接口 , List , Set 和 Map

1>Collection 接口存储一组不唯一(允许重复) , 无序的对象

2>Set 接口继承Collection 接口 , 存储一组唯一(不允许重复) , 无序的对象

3>List 接口继承Collection 接口 , 存储一组不唯一(允许重复) , 有序(以元素插入的次序来放置位置 , 不会重新排列) 的对象

4>Map 接口存储一组成对的键-值对象(可以对比着C#的hashtable 来记忆) 提供key (键) 到value (值) 的映射 . Map 中key 不要求有序 , 不允许重复 . value 不要求有序 , 可以重复

5>Iterator 接口是负责定义访问和遍历元素的接口

Java集合框架体系

下面我们就来详细了解ArrayList , LinkedList , HashSet , HashMap

List 接口 :

ArrayList：是数组结构，长度是可变的，原理（创建新数组+复制数组），查询速度快，增删较慢，不同步。ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑使用Collections.synchronizedList（List i）函数返回一个线程安全的ArrayList类，或者使用Concurrent并发包下对应的集合类。

使用ArrayList前需要导包 import java.util.ArrayList;

package BackPack;

import java.util.ArrayList;

public class Text {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		ArrayList<String> list = new ArrayList<String>();
		//使用add方法添加数据
		list.add("雪纳瑞");
		list.add("拉布拉多");
		list.add("哈士奇");
		//输出集合中狗狗种类的数量
		System.out.println("共计有" + list.size() + "种狗");
		//遍历集合显示各个信息
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}

}

List 接口中定义的各种常用方法

void add(int index , Object o) 　　//在指定的索引位置添加元素 , 原索引位置及其后面的元素依次后移

int size() 　　//返回列表中的元素个数

Object get(int index) 　　//返回指定索引位置处的元素注意 : 取出来的元素是Object类型 , 使用前需要进行强制类型转换

boolean contains( Object o) 　　　　//判断列表中是否存在指定元素

boolean remove( Object o) 　　　　//从列表中删除元素

Object remove (int index) 　　　　　//从列表中删除指定位置元素 , 起始索引位置从0开始

LinkedList：是基于双向循环链表实现的，是链表结构，不同步的，增删速度快，查询较慢。由于实现了Queue接口，因此也可以用于实现堆栈、队列。

package BackPack;

import java.util.LinkedList;    //首先进行导包

public class Text {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //1.创建LinkedList集合对象
        LinkedList<String> list = new LinkedList<String>();
        //2.添加元素
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("孙七");
        //3.查看第一个名字
        System.out.println("第一个名字 : " + list.getFirst());
        //4.查看最后一个名字
        System.out.println("第一个名字 : " + list.getLast());
        //5.查看指定名字
        System.out.println("第一个名字 : " + list.get(0));
        //6.删除集合中第一个名字和最后一个名字 , 删除指定位置名字
        list.removeFirst();
        list.removeLast();
        list.remove(0);
        //7.删除之后还有多少个名字
        System.out.println(list.size());
        //8.遍历输出
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

}

LinkedList的一些特殊方法

void addFirst(Object o)　　　　//在列表的首部添加元素

void addLast(Object o)　　　　//在列表的末尾添加元素

Object getFirst()　　　　　　　//返回列表中的第一个元素

Object getLast()　　　　　　　//返回列表中的最后一个元素

Object removeFirst()　　　　　//删除并返回列表中的第一个元素

Object removeLast()　　　　　//删除并返回列表中的最后一个元素

HashSet：基于HashMap实现，哈希表结构，不同步，保证元素的唯一性依赖于hashCode()，equals()方法。

Hash概述：哈希算法hash也称散列，结果叫哈希值。数组中存储的都是（元素与哈希值的）对应关系，该数组称为哈希表，查询速度比数组快，重复元素存不进去，保证元素的唯一性。

哈希冲突怎么解决？元素的哈希值（hashcode()）一致了，这是会再次判断元素的内容是否相同（equals()）,如果equlas返回true，意味着两个元素相同，如果返回的是false，意味着两个元素不相同，继续通过算法算出位置进行存储（拉链法）。

package BackPack;

import java.util.HashSet; //导包

public class Text {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // 泛型指定，万万不可写基础类型 都提供了一个对应的封装类
        // int -> Integer char->Char double -> Double 依次类推

        HashSet<Integer> hashset = new HashSet<Integer>();
        // 2.添加元素 本h质不可以添加重复的元素 , 如果添加了重复的元素 , 则后面添加的会覆盖前面的
        hashset.add(1);
        hashset.add(2);
        hashset.add(3);
        hashset.add(4);
        hashset.add(1);

        // 3.删除指定元素
        hashset.remove(3);

        // 修改 : 并没有提供特殊的方法 , 只能先删除后添加 改2->10
        hashset.remove(2);
        hashset.add(10);

        // 4.查询全部信息
        for (Integer num : hashset) {
            System.out.println(num);
        }

        // 5.查询集合中的数据量
        System.out.println("集合数量" + hashset.size());

    }

}

HashMap：数据结构为哈希表，不同步，允许null作为键和值，无序的

很多人开始会以为HashMap的键不能存null , 但其实它是可以的

package BackPack;

import java.util.HashMap; //导包

public class Text {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // 1.Map:HashMap  创建HashMap 集合对象
        HashMap<Integer, String> map = new HashMap<Integer, String>();

        // 2.map的键万万不能重复 可以存null 值随便重复
        map.put(1, "张三");
        map.put(2, "李四");
        map.put(3, "王五");
        map.put(4, "赵六");

        // 3.查询指定单个元素
        System.out.println(map.get(1));
        
        //4.删除指定单个元素
        System.out.println(map.remove(0));

        //5.遍历集合中值
        for (int i : map.keySet()) {
            System.out.println(i);
        }

    }

}

Map中常见方法：

1、添加：

1、V put(K key, V value) （可以相同的key值，但是添加的value值会覆盖前面的，返回值是前一个，如果没有就返回null）

2、putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。

2、删除

1、remove() 删除关联对象，指定key对象

2、clear() 清空集合对象

3、获取

1：value get(key); 可以用于判断键是否存在的情况。当指定的键不存在的时候，返回的是null。

3、判断：

　　1、boolean isEmpty() 长度为0返回true否则false

　　2、boolean containsKey(Object key) 判断集合中是否包含指定的key

　　3、boolean containsValue(Object value) 判断集合中是否包含指定的value

4、长度：

Int size（）

Arrays和Collections

Collections：集合框架中用于操作集合对象的工具类，都是静态方法。

1、获取Collection最值

2、对List集合排序，也可以二分查找

3、对排序逆序

4、可以将非同步的集合转成同步的集合

Arrays：用于操作数组的工具类，类中定义的都是静态工具方法。

1、对数组排序

2、二分查找

3、数组复制

4、将两个数组进行元素的比较，判断两个数组是否相同

5、将数组转成字符串

6、将数组转成list集合（asList方法），为了使用集合的方法操作数组中的元素

注意：数组长度是固定的，在转成集合后，长度也是固定的，所以不要使用集合的增删功能；如果数组中存储的是基本数据类型，那么转成集合后，数组对象作为集合中的元素存在；如果数组中元素是引用数据类型时，转成集合后，数组元素作为集合元素存在。

posted @ 2018-03-20 15:56 DailyGrowing 阅读(184) 评论(0) 收藏举报

刷新页面返回顶部

DailyGrowing

集合框架

公告