`
fehly
  • 浏览: 248436 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

集合与映射

    博客分类:
  • java
阅读更多
  • 集合框架概述

集合就是将若干用途,性质相同或相见的数组合成一个整体.

从体系上讲,集合类型可以归纳为三种:

  • 集(Set):Set集合中不区分元素的顺序,不允许出现重复元素.
  • 列表(List):List集合区分元素的顺序,且允许包含重复元素.
  • 映射(Map):映射中保存成对的"键-值"(Key-Value)信息,映射中不能包含重复的键,每个键最多只能映射一个值.
  • java集合中能保存引用类型的数据,实际上存放的对象时引用,而非对象本身,集合中元素相当于引用类型变量

Collection接口

java.util.Collection接口是描述Set和List集合类型的根接口,其中定义了有关集合操作的普遍性方法:

  • boolean add(Object o)
  • boolean remove(Object o)
  • int size()
  • boolean isEmpty()
  • boolean contains(Object o)
  • void clear()
  • Iterator iterator()
  • Object[] toArray()

Set和List接口

  • java.util.Set和java.util.List分别描述前述的集合列表结构,二者均为Collection的子接口。
  • List接口规定使用者可以对列表元素的插入位置进行精确控制,并添加了根据元素索引来访问元素等功能,接口中新天津了相应的方法:
  • void add(int index,Object element)
  • Object get(int index)
  • Object set(int index,Object element)
  • int indexOf(Object o)
  • Object remove(int index)

Map接口

java.util.Map接口描述了映射结构,Map结构允许以键集、值集合或键-值映射关系集的形式查看某个映射的内容.

主要方法:

  • Object put(Object key,Object value)
  • Object get(Object key)
  • boolean isEmpty()
  • void clear()
  • int size()
  • boolean containsKey(Object key)
  • boolean containsValue(Object value)
  • Set keySet()
  • Collection values()

集合相关API关系结构

ArrayList

  • java.util.ArrayList类实现了List接口,用于表述长度可变的数组列表
  • ArrayList列表允许元素取值为null,除实现了List接口定义的所有功能外,还提供了一些方法来操作列表容量的大小,相关方法包括:
  • public ArrayList()
  • public ArrayList(int initialCapacity)
  • public void ensureCapacity(int minCapacity)
  • public void trimToSize()
import java.util.Date;
import java.util.ArrayList;

public class TestArrayList{
	public static void main(String[] args) {
		ArrayList h = new ArrayList();
		h.add("1st");
		h.add("2nd");
		h.add(new Integer(3));
		h.add(new Double(4.0));
		h.add("2nd");      // 重复元素, 加入
		h.add(new Integer(3)); // 重复元素,加入
		System.out.println(h);		
		System.out.println("size=" + h.size());
		System.out.println("-----替换指定元素-----");	
		h.set(3,"replace");		
		System.out.println("-----for循环遍历-----");
		for(int i=0;i<h.size();i++){
			System.out.println(h.get(i));
		}		
		System.out.println("-----取用特定元素-----");		
		Integer it = (Integer)h.get(2);
		System.out.println(it.intValue());
		System.out.println("-----插入元素-----");		
		h.add(3,new Date());
		System.out.println("-----转换为数组-----");	
		Object[] os = h.toArray();
		for(Object o : os){
			System.out.println(o);	
		}		
	}
}

 Vector

java.util.vector也实现了List接口,其描述的也是可变长度的对象数组.

与ArrayList的差别:Vector是同步(线程安全)的,运行效率要低一些,主要用在多线程环境中,而ArrayList是不同步的,适合在单线程环境中使用。

常用方法(除实现List接口中定义的方法外):

  • public vector()
  • public Object elementAt(int index)
  • public void addElement(Object obj)
  • public void removeElementAt(int index)
  • public void insertElementAt(E obj,int index)
  • public boolean removeElement(Object obj)
  • public void removeAllElements()
  • public Object[] toArray()
import java.util.Date;
import java.util.Vector;

public class TestVector{
	public static void main(String[] args) {
		Vector v = new Vector();
		v.add("1st");
		v.add("2nd");
		v.add(new Integer(3));
		v.add(new Double(4.0));
		v.add("2nd");      // 重复元素, 加入
		v.add(new Integer(3)); // 重复元素,加入
		System.out.println(v);		
		System.out.println("size=" + v.size());
		System.out.println("-----替换指定元素-----");	
		v.set(3,"replace");		
		System.out.println("-----for循环遍历-----");
		for(int i=0;i<v.size();i++){
			System.out.println(v.get(i));
		}		
		System.out.println("-----取用特定元素-----");		
		Integer it = (Integer)v.get(2);
		System.out.println(it.intValue());
		System.out.println("-----插入元素-----");		
		v.add(3,new Date());
		System.out.println("-----转换为数组-----");	
		Object[] os = v.toArray();
		for(Object o : os){
			System.out.println(o);	
		}		
	}
}

 

Stack

java.util.Stack类继承了Vector类,对应数据结构中以"后进先出"(Last in First out,LIFO)方式存储和操作数据的对象栈.

Stack类提供了常规的栈操作方法:

  • public Stack()
  • public Object push(E item)
  • public Object pop()
  • Public Object peek()
  • public boolean empty()
  • public void clear()
  • public int search(Object o)
import java.util.Date;
import java.util.Stack;

public class TestStack{
	public static void main(String[] args) {
		Stack s = new Stack();
		s.push("hello");
		s.push(new Date());
		s.push(400);  //自动封装,等价于s.push(new Integer(400));
		s.push(3.14);
		
		System.out.println("弹栈前:size=" + s.size());
		System.out.println(s.pop());
		System.out.println("弹栈后:size=" + s.size());
		System.out.println(s.peek());
		System.out.println("peek操作后:size=" + s.size());
		while(!s.isEmpty())
			System.out.println(s.pop());
	}
}

 Iterator接口

java.util.Iterator接口描述的是以统一方式对各种集合进行遍历/迭代的工具,也称"迭代器".

允许在"遍历"过程中移除结合中的(当前遍历到的那个)元素.

主要方法:

  • boolean hasNext()
  • Object next()
  • void remove()
import java.util.Date;
import java.util.ArrayList;
import java.util.Vector;
import java.util.Iterator;

public class TestIterator{
	public static void main(String[] args) {
		ArrayList a = new ArrayList();
		a.add("China");
		a.add("USA");
		a.add("Korea");
		Iterator  it = a.iterator();
		while(it.hasNext()){
			String country = (String)it.next();
			System.out.println(country);	
		}		
		
		Vector v = new Vector();
		v.addElement(new Date());	
		v.addElement(new Date(200008755554L));
		it = v.iterator();
		while(it.hasNext()){
			Date time = (Date)it.next();
			System.out.println(time);	
		}			
	}
}

 HashSet

  • java.util.HashSet类实现了java.util.Set接口,描述典型的Set集合结构
  • HashSet中不允许出现重复元素,不保证集合中元素的顺序
  • HashSet中允许包含值为null的元素,但最多只能有一个null元素。
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;

public class TestHashSet{
	public static void main(String[] args) {
		HashSet h = new HashSet();
		h.add("1st");
		h.add("2nd");
		h.add(new Integer(3));
		h.add(new Double(4.0));
		h.add("2nd");      	// 重复元素, 未被加入
		h.add(new Integer(3)); 	// 重复元素,未被加入
		h.add(new Date()); 
		System.out.println("开始: size=" + h.size());
		Iterator it = h.iterator();
		while(it.hasNext()){
			Object o = it.next();
			System.out.println(o);	
		}
		
		h.remove("2nd");
		System.out.println("移除元素后: size=" + h.size());
		System.out.println(h);
	}
}

 TreeSet

  • java.util.TreeSet类也实现了java.util.Set,它描述的是Set的一种变体——可以显示排序的集合。
  • 在将对象元素添加到TreeSet集中时会自动按照某种比较规则将其插入到有序的对象序列中,以保证TreeSet集合元素组成的对象序列时刻按照"升序"排列.
import java.util.TreeSet;
import java.util.Iterator;

public class TestTreeSet{
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add("orange");
		ts.add("banana");
		ts.add("apple");
		ts.add("grape");

		Iterator it = ts.iterator();
		while(it.hasNext()){
			String fruit = (String)it.next();
			System.out.println(fruit);	
		}
	}
}

 Comparable接口

  • java.lang.Comparable接口中定义的compareTo()方法用于提供对其实现类的对象进行整体排序所需的比较逻辑。
  • 实现类基于compareTo()方法的排序被称为自然排序,而compareTo()方法被称为它的自然比较方法,具体的排序原则可由实现类根据需要而定
  • 用户在重新compareTo()方法以定制比较逻辑时,需要确保与等价性质判断方法equals()保持一致。
public class Person implements java.lang.Comparable{
	private final int id;
	private String name;
	private int age;
	
	public Person(int id,String name,int age){
		this.id = id;
		this.name = name;
		this.age = age;	
	}
	public int getId(){
		return id;	
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;	
	}
	public void setAge(int age){
		this.age = age;	
	} 
	public int getAge(){
		return age;	
	}
	public String toString(){
		return "Id: " + id + "\tName: " + name + "\tAge: " + age; 	
	}	
	@Override
	public int compareTo(Object o){
		Person p = (Person)o;
		return this.id - p.id;		
	}
	@Override
	public boolean equals(Object o){
		boolean flag = false;
		if(o instanceof Person){
			if(this.id == ((Person)o).id)
				flag = true;
		}
		return false;		
	}	
}
import java.util.TreeSet;
import java.util.Iterator;

public class TestComparable{
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add(new Person(1003,"张三",15));
		ts.add(new Person(1008,"李四",25));
		ts.add(new Person(1015,"王五",73));
		ts.add(new Person(1001,"赵六",49));

		Iterator it = ts.iterator();
		while(it.hasNext()){
			Person employee = (Person)it.next();
			System.out.println(employee);	
		}
	}
}

 HashMap

  • java.util.HashMap类实现了java.util.Map接口,该类基于哈希表实现了前述的映射集合结构。
  • HashMap结构不保证其中元素(映射信息)的先后顺序,并且允许使用null"值"和"null"键.
  • 当集合中不存在当前检索的"键"所对应的映射值时,HashMap的get()方法会返回null,而不会运行出错.
  • 影响HaspMap性能的两个参数:
  • 初始容量(Inital Capacity)
  • 加载因子(Load Factor)
import java.util.Set;
import java.util.HashMap;
import java.util.Collection;
import java.util.Iterator;

public class TestHashMap{
	public static void main(String[] args) {
		HashMap hm = new HashMap();
		hm.put(new Integer(1003),new Person(1003,"张三",15));
		hm.put(new Integer(1008),new Person(1008,"李四",25));
		hm.put(1015,new Person(1015,"王五",73));   //自动封装
		hm.put(1001,new Person(1001,"赵六",49));

		System.out.println("----检索单个元素----");
		Person p = (Person)hm.get(1008);
		System.out.println(p);
		
		System.out.println("----遍历所有\"键\"(元素名)----");
		Set names = hm.keySet();
		for(Object o : names){
			System.out.println(o);
		}
		
		System.out.println("----遍历所有\"值\"(元素值)----");
		Collection values = hm.values();
		for(Object o : values){
			System.out.println(o);
		}
	}
}

Hashtable 

 java.util.Hashtable与HashMap作用基本相同,也实现了Map接口,采用了哈希表的方式将"键"映射到哦相应的"值".

Hashtable 与HashMap的差别:

  • Hashtable中元素的"键"和"值"均不允许为null,而HashMap则允许
  • Hashtable是同步的,即线程安全的,效率相对要低一些,适合在多线程环境下使用;而HashMap是不同步的,效率相对高一些,提倡在单线程环境中使用.
  • Hashtable与HashMap的用法格式完全相同.

TreeMap

  • java.util.TreeMap类实现了将Map映射中的元素按照"键"进行升序排列的功能,其排序规则也可以是默认的按照"键"的自然顺序排序,也可以使用指定的其他排序规则.
  • 向TreeMap映射中添加的元素"键"所属的类必须实现Comparable接口

Enumeration接口

java.util.Enumeration接口作用与Iterator接口类似,但只提供了遍历Vector和Hashtable(及子类Properties)类型集合元素的功能

Collections类

java.util.Collections类中定义了多种集合操作方法,实现了对集合元素的排序,取极值,批量拷贝,集合结构转换,循环移位以及配性检查等功能:

主要方法:

  • public static void sort(List list)
  • public static void reverse(List list)
  • public static void shuffle(List list)
  • public static void copy(List dest,List src)
  • public static ArrayList list(Enumeration e)
  • public static int frequency(Collection c,Object o)
  • public static T max(Collection coll)
  • public static T min(Collection coll)
  • public static void rotate(List list,int distance)
import java.util.Vector;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;

public class TestCollections{
	public static void main(String[] args) {
		ArrayList alist = new ArrayList();
		alist.add(75); 
		alist.add(38); 
		alist.add(21); 
		alist.add(4); 
		alist.add(12); 

		System.out.println("原列表: " + alist);
		Collections.sort(alist);
		System.out.println("排序后: " + alist);
		Collections.reverse(alist);
		System.out.println("逆序后: " + alist);
		Collections.shuffle(alist);
		System.out.println("混排后: " + alist);
		Collections.rotate(alist,2);
		System.out.println("移位后: " + alist);		
		
		ArrayList blist = new ArrayList();
		blist.add(55); 
		blist.add(66);
		System.out.println("新列表: " + blist);
		Collections.copy(alist,blist);
		System.out.println("拷贝后: " + alist);

		System.out.println("列表中出现元素66的次数: " + Collections.frequency(alist,66));
		System.out.println("列表中元素的最大值: " + Collections.max(alist));
		System.out.println("列表中元素的最小值: " + Collections.min(alist));

		Enumeration en = createDemoEnumeration();
		ArrayList clist = Collections.list(en);
		System.out.println("Enumeration->ArrayList: " + alist);
	}
	
	public static Enumeration createDemoEnumeration(){
		Vector v = new Vector();
		v.add("Tom");		
		v.add("Billy");		
		v.add("Jenny");		
		return v.elements();	
	}
}

 Arrays类

java.util.Arrays类定义了多种数组操作方法,实现了对数组元素的排序,填充,转换为列表或字符串形式,增强的检索和深度比较等功能.

主要方法:

  • public static List asList(Object... a)
  • public static  void sort(<类型>[] a)
  • public static int binarySearch(int[] a,int key)
  • public static String toString(int[] a)
import java.util.List;
import java.util.Arrays;

public class TestArrays{
	public static void main(String[] args) {
		Integer[] a = {3,25,12,79,48};
		System.out.println(a);
		System.out.println(Arrays.toString(a));
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
		int idx = Arrays.binarySearch(a,25);
		System.out.println(idx);
		
		List list = Arrays.asList(3,4,5);
		System.out.println(list);
		list.set(2,66);
		System.out.println(Arrays.toString(a));
	}
}

 

分享到:
评论

相关推荐

    java集合与映射(牛)

    ### Java集合与映射详解 #### 一、Java集合框架概览 在Java编程语言中,集合框架(Collection Framework)是一组接口和实现这些接口的类的集合,它提供了存储和操作一组对象的方式。Java集合框架主要包括两种类型...

    3 集合与映射

    集合论是数学的一个基础分支...集合的定义、表示、关系和运算为数学语言的表达提供了严格的形式化工具,而数集的表示、实数的性质、确界与连续性公理、区间与邻域的概念为分析实数集合和函数行为提供了必要的数学基础。

    集合与映射.ppt

    《集合与映射》 集合是数学的基础概念之一,它是指将一类特定对象组合成的整体。集合的元素可以是任何事物,例如数字、字母、点、线等。集合的表示通常使用大写字母,如A、B、C等。若元素a属于集合A,我们用符号"a...

    高等代数 集合与映射PPT学习教案.pptx

    【高等代数 集合与映射】是数学中的基础概念,主要研究对象是集合以及集合之间的关系和映射。集合是数学的基础,而映射则是连接不同集合的桥梁。 1. **集合的定义与表示** - 集合是由一组具有特定属性的事物组成的...

    高考数学集合与映射专题复习指导.docx

    《高考数学集合与映射专题复习指导》 在高中数学的复习阶段,集合与映射是基础也是重要的知识点,它们不仅是数学逻辑的基础,也是理解和掌握其他数学概念的关键。本复习指导将聚焦这两个主题,帮助考生深入理解并...

    高等数学——集合与映射PPT学习教案.pptx

    【高等数学——集合与映射】是数学的基础概念,尤其对于理解抽象的数学问题和后续的数学课程至关重要。本章主要涵盖了三个核心知识点:集合的基本概念、集合的基本运算以及映射的基本概念。 首先,**集合的基本概念...

    高考数学复习:集合与映射专题复习指导.docx

    【高考数学复习:集合与映射专题复习指导】 在高考数学中,集合与映射是重要的基础概念,常出现在选择题和填空题中。复习这部分内容时,不仅需要掌握集合的基本运算,如交集、并集和补集,还要能运用这些知识解决...

    高考数学一轮复习集合与映射专题复习指导.docx

    【高考数学一轮复习集合与映射专题复习指导】 在高考数学的复习阶段,集合与映射是基础且重要的概念,通常以选择题和填空题的形式出现。这部分内容不仅涉及集合的基本运算,如交集、并集和补集,还常常与其他数学...

    高三数学知识点:集合与映射专题复习指导.docx

    高三数学复习中的一个重要专题是集合与映射。这部分知识在高考中常以选择题和填空题的形式出现,虽然不总是直接围绕集合概念,但往往结合其他数学领域,如函数、三角函数、不等式、排列组合等。复习时,审题能力至关...

    高考数学复习指导:集合与映射专题复习指导.docx

    集合与映射是高中数学中的基础概念,它们在高考数学中常常作为考点出现,主要以选择题和填空题的形式考查。复习这部分内容时,考生需要掌握集合的基本性质、运算规则以及简易逻辑中的充要条件。 1. 集合的基本操作...

    集合,映射与运算.pdf

    集合的对等性意味着两个集合可以通过双射建立一一对应,自然数集合是无界且可数的,与之对等的集合被称为可数集合。如果无法建立这样的对应关系,则称为不可数集合。基数用来度量集合的大小,相等的基数表示两个集合...

    Hibernate集合映射与关联关系

    本主题将深入探讨Hibernate集合映射与关联关系,包括"student与Score的Map集合关系"、"student与class的多对一"以及"一对多映射"的概念。 首先,让我们理解一下Hibernate中的集合映射。在关系型数据库中,一个实体...

    hibernate集合的映射

    在Java的持久化框架Hibernate中,集合映射是将数据库中的表关系映射到对象的集合属性上,以便实现对象关系映射(ORM)。本文将深入探讨Hibernate中的四种主要集合映射类型:Set、List、Array和Map,以及它们在实际...

    hibernate map 集合映射

    在Java的持久化框架Hibernate中,集合映射是将数据库中的表关系映射到对象的集合属性上,以便更好地管理和操作数据。这篇文章将深入探讨Hibernate中的集合映射机制,包括其基本概念、类型以及如何在实际开发中进行...

    hibernate set 集合映射

    Set是最常见的集合映射类型,它不允许重复元素,与数据库中的唯一约束相对应。 2. **元素类型**:集合中的每个元素都是一个实体对象,它们通常通过@ManyToOne或@OneToOne关联映射到单独的数据库表。 3. **关联映射...

    多映射集合类

    总的来说,多映射集合类是一种强大的工具,尤其适用于需要存储键与多个值之间关系的场景,如日志记录(每个事件可能有多个标签)、用户偏好设置(一个用户可能有多个喜好项)等。通过扩展C#的Dictionary类并实现线程...

    人教a版_数学_高一必修1课时作业8分段函数与映射.pdf

    - 映射是指从一个集合(定义域A)到另一个集合(值域B)的一种对应关系,其中每个A中的元素都与B中唯一的元素对应。在题目中,映射的特点是A中的元素可以对应B中的一个或多个元素,但B中的元素可能没有对应项。例如...

    高等数学集合与函数.ppt

    在微积分学的第一讲中,主要围绕集合与映射这两个核心概念展开,它们是构建数学分析理论的基础。 首先,我们要了解集合的概念。集合是由一些特定对象组成的整体,这些对象称为集合的元素。集合的表示方法主要有列举...

Global site tag (gtag.js) - Google Analytics