Java集合（全家桶）

一，Collection集合概述：

（1）集合是存储其他对象的特殊对象。可以将集合当做一个容器。

（2）集合的相关接口和类位于java.util包中。

（3）集合中的接口和类是一个整体、一个体系。

集合优点：数据类型不统一，长度不固定。

 

二，集合接口：

集合框架定义了一些接口，它们决定了集合类的本质特性。具体的集合类只是提供了标准接口的不同实现。

注意：

1、Collection接口中没有提供修改元素的方法。

2、Collection接口的父接口是Iterable接口，实现了Iterable接口的类是可以迭代的。

接  口	描  述
Collection	允许操作一组对象，它位于集合层次结构的顶部
List	扩展Collection，以处理序列(对象列表)
Deque	扩展Queue，以处理双端队列
Set	扩展Collection，以处理组，组中的元素必须唯一

集合类：

类	描  述
ArrayList	动态数组
LinkedList	链表
ArrayDeque	双端队列 = 队列 + 堆栈
PriorityQueue	支持基于优先级的队列
HashSet	使用哈希表存储元素的组
LinkedHashSet	扩展HashSet类，以允许按照插入的顺序进行迭代
TreeSet	实现存储于树中的集合。

三，Collection常用的子接口：

Collection是集合类最大的父接口，下面是它的子接口（实现类）：


 

List

List集合：分为Arraylist，Linkedlist与Vector。

ArrayList：

      基于数组, 查询效率高, 增加, 删除效率低, 线程不同步。

 ArrayList实现了List接口。本质上是元素为对象引用的长度可变的数组。

ArrayList常用方法如下：

package listdemo;
import java.util.List;
import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		//泛型：参数化类型==》类型参数化  JDK1.5之后
		List list=new ArrayList();
		//Element=》元素-E
		
		//向集合中添加数据=>追加  add(元素)  
		list.add("One");  //Integer
		
		list.add("Two");  //Integer
		list.add("Three");  //Integer
		
		//插入 操作  add(插入位置，插入元素);
		list.add(1,"我");
		
		//通过下标查找  get(下标)  通过下标找元素
//		String string = list.get(2);
		
		//集合元素个数的   size()
		for(int i=0;i

 

ArrayList集合的循环遍历,如下：

 

package cam;

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

public class Demo {
	
	public static void main(String[] args) {
		List list=new ArrayList();
		list.add("One");
		list.add("Two");
		list.add("Three");
		list.add("Four");

	
		//第一种List 集合的循环遍历方法
		//1：集合个数，2：get方法
		//掌握程度*   最好理解的写法
//		for(int i=0;i it=list.iterator();
		//it.hasNext() 代表  是否存在下一个 元素
		//it.next()     将下一个元素返回  并且指针下一（指针人为定义）
		//it.remove()	迭代器  remove方法 
		while(it.hasNext()){
			String str =it.next();
			if(str.equals("Three")){
				it.remove();
//				list.remove("Three");  
				//break;
				//使用迭代器删除操作  不要使用集合的删除  建议使用迭代器的删除，
				//如果使用集合的删除操作    必须使用break
			}
		}
	}
	
    

LinkedList:

基于链表, 查询效率低, 增加, 删除效率高, 线程不同步。

     

LinkedList类实现了List、Deque以及Queue接口。

它提供了（双向）链表数据结构。

具体实现就不写了，下面写一些它的常用方法：

 注：List 接口中所有的方法 ，LinkedList 也存在。

LinkedList独有的方法：

1，addFirst() 添加到集合的首部

2，addLast() 添加到集合的尾部

3，getFirst(); 获取第一个元素

4，getLast()  获取最后一个元素

5，removeFirst(); 删除第一个元素

6，removeLast() 删除最后一个元素

ArrayList与LinkedList的区别：

1、ArrayList是基于数组结构的集合，有容量的概念；LinkedList是基于链表结构的集合，没有容量的概念

2、对于随机访问（get和set方法），ArrayList优于LinkedList，因为LinkedList要移动指针。

3、对于新增和删除操作（add和remove方法），LinkedList比较占优势，因为ArrayList要移动数据。但是如果只是在末尾追加元素，并且没有超出容量限制，则ArrayList的性能更好。

4、LinkedList 还实现了Queue接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等。            

 Vector： 

       限制线程同步的一个线程安全的list集合。Stack是Vector的子类，Stack与Vector一样，是线程安全的，但是性能较差，尽量少用Stack类。如果要实现栈”这种数据结构，可以考虑使用LinkedList。按照原来长度的2倍扩容。

Set

Set集合 ：是一个无序且不可重复的集合：分为HashSet,TreeSet与LinkedHashSet。

HashSet：

         基于HashCode 码实现

HashSet类实现了Set接口。该类在内部使用哈希表存储元素。

哈希表使用称之为散列法(hashing)的机制存储信息。

希法的优点是add()、contains()、remove()以及size()方法的执行时间保持不变，即使是对于比较大的集合也是如此。HashSet()  //默认容量是16。

HashSet中元素不是按有序的顺序存储的，遍历输出HashSet中的元素时精确的输出可能不同。

HashSet实现测试，如下：

package cbm;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetTest {
	public static void main(String[] args) {
		//创建Set 集合
		//HashSet  是基于HashCode 码 进行排列的
		Set  set=new HashSet();
		//添加 add();
		//当出现 重复的元素  返回false 代表不允许添加重复元素
//		boolean f1 = set.add("你好");
//		boolean f2 = set.add("你好");
//		boolean f3 = set.add("你好");
//		set.add(" ");
//		set.add("");
//		set.add(null);
//		System.out.println(f1);
//		System.out.println(f2);
//		System.out.println(f3);
		
		//清空集合 clear()
		
		//contains 是否包含指定元素
//		boolean contains = set.contains("你");
//		System.out.println(contains);
				
		//是否为空  isEmpty();
		
		//删除元素 remove(元素);  Set集合本身是无序所以没有下标
//		boolean remove = set.remove("你好");
//		System.out.println(set.isEmpty());
//		size（） 获取集合元素的个数
//		System.out.println(set.size());
		
//		Iterator it = set.iterator();
//		while(it.hasNext()){
//			Object o=it.next();
//			System.out.println(o);
//		}		
	}
}

TreeSet：

       基于二叉树实现，最大的特点就是元素会按照自然顺序排序。

TreeSet类实现了NavigableSet接口，该类在内部使用树结构存储元素。元素以升序存储，访问和检索相当快。

TreeSet适合于存储大量的、必须能够快速查找到的有序信息。

Set与List的区别：

1、Set中的元素不能重复，List中的元素可以重复。
2、List有索引（下标）的概念，Set没有索引的概念。
3、对于Set表示的集合，通常是遍历操作，没有get()和set()方法。

注意：

TreeSet以升序保存对象，所以TreeSet中保存的对象比较能够比较大小，即TreeSet保存的对象类型必须实现Comparable接口。

package cbm;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SetTest1 {

	public static void main(String[] args) {
		Student s1 = new Student(12,"张三");
		Student s2 = new Student(14,"李四");
		Student s3 = new Student(1,"王五");
		Student s4 = new Student(25,"赵六");
		//使用TreeSet 添加的元素的数据类型 必须实现Comparable 比较器
		Set  set=new  TreeSet();
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s4);
		Iterator it = set.iterator();
		while(it.hasNext()){
			Student s=it.next();
			System.out.println(s);
		}
	}
	
}

//学生类
package cbm;

public class Student implements Comparable{
	
	private int age;
	private String name;
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Student(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}
	
	//比较器的方法
	@Override
	public int compareTo(Object o) {
		Student s=(Student)o;
		if(s.getAge()>this.getAge()){
			return -1;
		}
		return 1;
	}

//了解
	//Set中 比较相同的方法是equals，HashCode 码是否相同
	@Override
	public boolean equals(Object obj) {
		Student  s=(Student)obj;
		if(s.getName().equals(this.getName())&&s.getAge()==this.getAge())
		return true;
		return false;
	}
	
	@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		return 1;
	}
}

LinkedHashSet类：

      扩展了HashSet类，它没有添加它自己的方法。

LinkedHashSet在内部使用一个链表维护元素添加到集合中的顺序，因此可以按照插入顺序迭代集合。

下面是对一些实现方法：

package cbm;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;

public class SetTest2 {

	public static void main(String[] args) {
		//LinkedHashSet Set集合中唯一有插入顺序的集合
		LinkedHashSet lhs=new LinkedHashSet();
//		HashSet lhs=new HashSet();
		lhs.add("你好");
		lhs.add("我好");
		lhs.add("大家好");
		lhs.add("都好,都好");
		
		Iterator it = lhs.iterator();
		while(it.hasNext()){
			String next = it.next();
			System.out.println(next);
		}
	}
}

注意：Set类型的集合（实现Set接口的类）称为集，有些资料称为组，其特点是组中的元素必须唯一。

HashSet是无序的，LinkedHashSet和TreeSet是有序的。

四，遗留的集合类与接口 

在集合之前，Java提供了特定的类，存储和管理对象组，例如Dictionary、Vector、Stack和Properties。

早期版本的java.util包没有包含集合框架。反而，定义了几个类和接口，提供存储对象的专门方法。当添加集合时(由J2SE 1.2添加)，对几个原始类进行了重新设计，以支持集合接口。因此，从技术上讲它们现在是集合框架的组成部分。

前面介绍的所有现代集合类都不是同步的，但是所有遗留类都是同步的。

1 ，Vector类

现在Vector类实现了动态数组，与ArrayList类似，也实现List接口。但有如下区别：

l  Vector实现同步，线程安全。ArrayList没有实现线程安全。

l  Vector性能比ArrayList低。

l  Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间（2n），而ArrayList每次对原长度增加1.5倍加1（公式：oldLength+oldLength/2+1，即：每一次增加1.5倍）。

2， Hashtable类

Hashtable类也实现了Map接口，与HashMap类似。

主要区别：

1、Hashtable是同步的、线程安全的，而HashMap不是同步的，没有实现线程安全。

2、HashMap允许将null作为一个条目的key或者value，而Hashtable不允许。当然只能有一个条目的键为null。

3、HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。

五，比较特殊的集合：Map集合（这里只介绍HashMap）

HashMap基本方法：

package cbm;

import java.util.Map;
import java.util.HashMap;

public class MapTest {

	public static void main(String[] args) {
		Map map=new HashMap();
//      从增删改查xueqi   
//		增加  put(键，值)
//		map.put("One", "壹");
		//增加
//		map.put("Two", "贰");
		
		//查寻	 get(键);  通过键找到值
//		String s=map.get(11);
//		System.out.println(s);
		
		//删除  remove(键)  通过键删除键与值的映射关系  返回 原有的value的值
//		String  sss=map.remove("Two");
//		System.out.println(sss);
		
//		System.out.println(map.get("Two"));
		
//		map.put("Two","叁");
		
		//clear() 清空集合
		//size()  map 集合的键值关系数
		//isEmpty()  当前集合是否为空集合  size 是否为0;
//		System.out.println(map.size());
//		map.clear();
//		System.out.println(map.size());
		
		//当前集合是否包含某一个键 containsKey
//		boolean ck = map.containsKey("壹");
//		System.out.println(ck);
		
		//当前集合是否包含某一个值containsValue
//		boolean cv = map.containsValue("One");
//		System.out.println(map.get("Two"));
//		System.out.println(cv);
	}
}

Map集合遍历方法：

package cbm;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class MapTest1 {

	public static void main(String[] args) {
		Map map=new HashMap ();
		map.put("One", "壹");
		map.put("Two", "贰");
		map.put("Three", "叁");
		map.put("Four", "肆");
		
		//遍历第一种方式
		//map 遍历本身没有迭代器  需要一个有迭代器的集合接收 map 对象的元素
		//这个set 集合中存放着map 集合的键
		//keySet()  将 map 集合对象的键 放入一个新的Set 集合对象中
		//*****
//		Set set=map.keySet();
//		for(String s:set){
//			String key=s;
//			String value=map.get(key);
//			System.out.println(key+"====="+value);
//		}
		
		//遍历第二种方式  直接遍历值
		//如果单纯遍历值  可以使用 values 方法
		//返回的结果 不是Set 集合而是Collection集合
//		Collection cl = map.values();
//		Iterator it = cl.iterator();
//		while(it.hasNext()){
//			String value = it.next();
//			System.out.println(value);
//		}
		
		//遍历第三种方式  将键与值 一次性取出  
		//**
		Set> set = map.entrySet();
		Iterator> it = set.iterator();
		while(it.hasNext()){
			Entry en = it.next();
			System.out.println(en.getKey()+"========"+en.getValue());
		}
	}
}

 

更多相关Map集合的知识点击进入“映射篇”。