面向对象,集合篇(1)

一、集合的概念

集合石包含多个对象的简单对象,所包含的对象称为元素。集合里面可以包含任意多个对象,数量可以变化;同时对象的类型也没有限制的,也就是说集合里面的所有对象的类型可以相同,也可以不同。

我们以前用来存储对象使用的自己用数组写的Set,长度和类型都是单一的,功能也没有这么全。但是需要注意的是集合类存放的都是对象的引用,而不是对象本身。

二、数据结构分类

(1)顺序存储     (2)链式存储     (3)树形存储      (4)散列存储Hash     (5)Map映射存储

三、集合框架是由一组用来操作对象的接口组成,不提接口描述不同类型的组。(下图是Java集合框架)

集合框架接口和其特点:

1:Collection接口是一组允许重复的对象。

2:Set接口承Collection,无序但不允许重复。

3:List接口继承Collection,有序但允许重复,并引入位置下标。

4:Map接口既不继承Set也不继承Collection,是键值对。

下面详细介绍这几种集合框架接口

Collection接口:

概念: Collection接口用于表示任何对象或元素组。想要尽可能以常规方式处理一组元素时,就使用这一接口。

Iterator接口:主要用来枚举集合中的元素。 可理解成集合的查寻组件。迭代器又称枚举器,就是把集合中的元素一个个枚举出来,就相当于拿着学生的花名册一个个点名。

组操作:Collection接口支持的其它操作,要么是作用于元素组的任务,要么是同时作用于整个集合的任务。

boolean contains( Object obj )                 ----------判断其中是否含有指定元素

boolean addAll( Collection collection )     ----------取并集

void clear()                                               ----------移除此 collection 中的所有元素

void removeAll( Collection collection )     ----------移除此 collection 中那些也包含在指定 collection 中的所有元素

void retainAll( Collection collection )        ----------取交集

Set接口:

概念:按照定义,Set接口继承Collection接口,而且它不允许集合中存在重复项。所有原始方法都是Collection中现成的,没有引入新方法。

具体的Set实现类依赖添加的对象的equals()方法来检查等同性。

HashSet类和TreeSet类:

“集合框架”支持Set接口两种普通的实现:HashSet和TreeSet。在更多情况下,会使用HashSet存储重复自由的集合。考虑到效率,添加到HashSet的对象需要采用恰当分配散列码的方式来实现hashCode()方法。当需要从集合中以有序的方式抽取元素时,TreeSet实现会有用处。为了能顺利进行,添加到TreeSet的元素必须是可排序的。

List接口:

概念:List接口继承了Collection接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理,还添加了面向位置的操作。

面向位置的操作包括插入某个元素或Collection的功能,还包括获取、除去或更改元素的功能。在List中搜索元素可以从列表的头部或尾部开始,如果找到元素,还将报告元素所在的位置。

void add(int index, Object element)                      ----------加到指定位置

boolean addAll(int index, Collection collection)    ----------把collection里的元素全部加进去,返回布尔型

Object get(int index)                                             ----------获取指定位置的元素

int indexOf(Object element)                                  ---------- 返回此列表中首次出现的指定元素的索引,或如果此列表不包含元素,则返回 -1

int lastIndexOf(Object element)                            ----------返回此列表中最后一次出现的指定元素的索引,或如果此列表不包含索引,则返回 -1

Object remove(int index)                                      ----------移除此列表中指定位置上的元素

Object set(int index, Object element)                   ----------替换指定位置的元素

List subList(int fromIndex, int toIndex)

注意:

1)使用List(如ArrayList)时,不会自动调用hashCode()方法。因为在List中,重复了就重复了,不需判断,保证唯一性。

2)List中添加了下标index的功能,这样对List的修改可以利用set方法对指定位置的元素直接进行替换,不需要象Set那么复杂(要转换成数组才能修改,之后还要转换回去)。

3)Collection用Iterator迭代器,而List可以用ListIterator列表迭代器。前者只能next(),后者不但包含next()方法,还包含previous()方法。因此,如果要用List做类似书的翻页功能,不但可以向后翻,还可以向前翻。

在“集合框架”中有两种常规的List实现:ArrayList和LinkedList。 如果要支持随机访问,而不必在除尾部的任何位置插入或除去元素,那么,ArrayList提供了可选的集合。但如果要频繁的从列表的中间位置添加和除去元素,而只要顺序的访问列表元素,那么LinkedList实现更好。、

下面利用ArrayList实现队列和栈:

队列实现代码:

import java.util.ArrayList;
import java.util.List;
/*
 * 采用ArrayList集合来实现队列的入队列,出队列,是否为空操作
 */
public class MyQue {
	private List<Object> list =new ArrayList<Object>(); //定义一个ArrayList集合
	int index=0; //队列指针,指向最后一个元素
	public void in(Object obj){ //进队列
		list.add(index, obj); //每次添加在队列的最末尾
		index++;
	}
	public Object out(){ //出队列
		Object obj=list.remove(0); //从集合中取第一个元素弹出
		index--;
		return obj;
	}
	public boolean isEmpty(){ //判断队列是否为空
		return list.isEmpty(); //直接判断集合是否为空
	}
}

栈实现代码:

import java.util.ArrayList;
import java.util.List;
/*
 * 采用ArrayList集合来实现栈的入栈,出栈操作。
 */
public class MyStack {
	private List<Object> list=new ArrayList<Object>(0);//定义一个ArrayList集合
	private int index=0;//栈指针,指向栈的最后一个元素
	public void push(Object obj){ //入栈
		list.add(index,obj); //把需要入栈的元素加入到list中
		index++;
	}
	public Object pop(){//出栈
		index--;
		Object obj=list.get(index); //弹出栈尾的元素
		list.remove(index); //移除弹出去的元素
		return obj;
	}
}

ArrayList代码演示:

import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo {
	public static void main(String[] args) {
		List<Student> list =new ArrayList<Student>(); //创建ArrayList接口
		 //new元素对象,在这里是Student对象
		Student s1=new Student("1001","zhou",67);
		Student s2=new Student("1002","zhou",57);
		Student s3=new Student("1003","zhou",57);
		Student s4=new Student("1004","zhou",97);
		//把上面的对象加入list中
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		//输出对象
		for(int i=0;i<list.size();i++){
			Student s=list.get(i);
			System.out.println(s);
		}
	}
}

结果:

LinkedList代码演示:

import java.util.LinkedList;
public class LinkedListDemo {
	public static void main(String[] args) {
		LinkedList<Object> list=new LinkedList<Object>(); //创建linkedList接口
		//new元素对象,在这里是Student对象
		Student s1=new Student("1001","zhou",67);
		Student s2=new Student("1002","zhou",57);
		Student s3=new Student("1003","zhou",57);
		Student s4=new Student("1004","zhou",97);
		//把上面的对象加入list中
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		list.add("abcd");
		list.add(100);
		//把aaa添加在list中的第一个位置
		list.addFirst("aaa");
		//移除位置序号为3的元素
		list.remove(3);
		//把位置序号为2的元素修改为88
		list.set(2, 88);
		//输出
		for(int i=0;i<list.size();i++){
			Object obj=list.get(i);
			System.out.println(obj);
		}
		//输出第一个元素
		System.out.println(list.getFirst());
	}
}

结果:

Student对象代码:

public class Student {
	private String sno, sname;
	private int score;
	//构造函数
	public Student(String sno, String sname, int score) {
		this.sno = sno;
		this.sname = sname;
		this.score = score;
	}
	//下面是对应参数的get、set函数
	public String getSno() {
		return sno;
	}
	public void setSno(String sno) {
		this.sno = sno;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	//toString函数
	@Override
	public String toString() {
		return "Student [sno=" + sno + ", sname=" + sname + ", score=" + score
				+ "]";
	}
}

Map接口:

概念: Map接口不是Collection接口的继承。而是从自己的用于维护键-值关联的接口层次结构入手。按定义,该接口描述了从不重复的键到值的映射。

Object put(Object key,Object value)  ---------新增or修改

Object remove(Object key)                ---------通过key修改

void putAll(Map mapping)                 ----------把一个map中的元素加入进去

void clear()                                        ----------从列表中移除所有元素

Object get(Object key)                      ----------通过key值或的value值

Map.Entry接口:Map的entrySet()方法返回一个实现Map.Entry接口的对象Set集合,其中每个对象都是底层Map中一个特定的键-值对。

HashMap类和TreeMap类:(都是实现了Cloneable接口)

“集合框架”提供两种常规的Map实现:HashMap和TreeMap。在Map中插入、删除和定位元素,HashMap是最好的选择。但如果要按顺序遍历键,那么TreeMap会更好。

使用HashMap要求添加的键类明确定义了hashCode()实现(助理解:Map.keySet返回的是键的Set集合,而Set集合对hashCode实现有限制,因此作为键的类也要遵守该限制)。有了TreeMap实现,添加到映射的元素一定是可排序的。

Hashmap代码演示:

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 HashMapDemo {
	public static void main(String[] args) {
		HashMap map = new HashMap();  //创建HashMap接口
		// 增加
		map.put("1001", "张军");
		map.put("1002", "张萨");
		map.put("1003", "王军");
		map.put("1014", "刘胜");
		map.put("1015", "张三");
		// 删除
		map.remove("1001");
		// 修改
		map.put("1003", "Mary");
		// 查找
		// 遍历法1:通过key视图
		Set keys = map.keySet();     //返回此映射中所包含的键的 Set 视图
		Iterator it = keys.iterator();  //使用迭代器读取数据
		//一个一个从迭代器中读取数据
		while (it.hasNext()) {
			String key = (String) it.next();
			String values = (String) map.get(key); //通过key值获取对应的value值
			System.out.println(key + "," + values); //输出
		}
		//遍历法2:通过entry视图
		System.out.println("-----------------------------");
		Set entries=map.entrySet();     //返回此映射所包含的映射关系的 Set 视图。
		Iterator it2=entries.iterator();  //使用迭代器读取数据
		while(it2.hasNext()){
			Map.Entry entry=(Entry)it2.next();
			String key =(String)entry.getKey();
			String values=(String) map.get(key);
			System.out.println(key+","+values);
		}
		//遍历法3:通过value视图 ,这种不能输出key值
		System.out.println("---------------------");
		Collection values=map.values();  //返回此映射所包含的值的 Collection 视图
		Iterator it3=values.iterator();  //使用迭代器读取数据
		while(it3.hasNext()){
			String value=(String) it3.next();
			System.out.println(value);
		}
	}
}

结果:

TreeMap代码演示:

import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo {
	public static void main(String[] args) {
		TreeMap map=new TreeMap();
		map.put("1001", "张军");
		map.put("1002", "张萨");
		map.put("1003", "王军");
		map.put("1014", "刘胜");
		map.put("1015", "张三");
		//遍历:通过entry视图
		Set entries=map.entrySet();  //返回此映射所包含的映射关系的 Set 视图
		Iterator it=entries.iterator();
		while(it.hasNext()){
			Map.Entry entry=(Entry)it.next();
			String key=(String) entry.getKey();
			String Value=(String) entry.getValue();
			System.out.println(key+","+Value);
		}
	}
}

结果:

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-11-05 16:01:32

面向对象,集合篇(1)的相关文章

面向对象 集合篇

集合概念: 集合本质上是一个动态数组 2.命令引用:using system.collections 2.1 Arratlist 属性(count) 数量 .属性2(capactity) 有几个位子 //集合里包括属性和方法2.2 arratlist list =new arraylist(); list.add(欲添加的值) object 类型的 为什么这里可以使object 类型的? 是因为object 是所有类型的父类,父类引用指向子类对象 所有类型都可以放在集合中去. 2.3 集合与数组

面向对象集合篇

1.动态数组ArrayList 2.List<T> 3.字典 Dictionary <string,Dog> dic = new Dictionary<string,Dog> (); 4.栈操作出栈pop 入栈push 获取栈顶元素peek 5.队列是两段开头的羽毛球筒子 6.Dequeue出队,Enqueue入队. 原文地址:https://www.cnblogs.com/xiaomao21/p/8330779.html

黑马程序员——集合篇

------- android培训.java培训.期待与您交流! ---------- 1.集合类 为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一 种方式. 数组和集合类同是容器,有何不同? 数组虽然也可以存储对象,但长度是固定的:集合长度是可变的.数组中可以存储基本数据类型,集合只能存储对象. 集合类的特点 集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象. 2.集合框架的构成及分类 3.

【JAVA秒会技术之秒杀面试官】秒杀Java面试官——集合篇(一)

[JAVA秒会技术之秒杀面试官]秒杀Java面试官--集合篇(一) [JAVA秒会技术之秒杀面试官]JavaEE常见面试题(三) http://blog.csdn.net/qq296398300/article/category/6876287

backbonejs中的集合篇(一)

一:集合概念 集合是多个模型,如果把模型model理解为表结构中的行,那么集合collection就是一张表,由多个行组成.我们经常需要用集合来组织和管理多个模型. 二:创建集合 1:扩展Backbone.Collection对象,指定为哪个模型创建集合,传参数model. var _collection = Backbone.Collection.extend({ model: _model }); 2:创建集合实例,传模型数组参数来初始化; 现假定_model的dafault属性为(name

部署SCCM 2012R2之七:安装客户端代理&创建集合篇

由于前段时间公司事情较多,博客也好久未更新,今天就按照之前所讲的内容继续前进,在微软的产品中许多客户端都需要代理的支持,才能完成某些工作任务,如SCVMM.SCCM.SCOM都是如此,在SCCM中不管是软件分发.软件资产.硬件资产,远程控制等都需要安装SCCM的代理. 而创建集合主要是便于管理员根据某些集合而做相应的策略部署,集合主要有用户集合和设备集合.在用户集合中可以创建以OU(如IT.Sales.HR)等为单位的集合,也可以创建以区域(如上海.北京.广州)等为单位的集合,设备集合可以创建不

面向对象(高级篇之抽象类与接口的应用)

抽象类的实际应用-----模板设计 接口的实际应用--------制定标准 设计模式-------工厂设计 程序在接口和子类之间加入了一个过渡端,通过此过渡端取得接口的实例化对象. 设计模式-------代理设计 所谓的代理设计就是指由一个代理主题来操作真实主题,真实主题执行具体的业务操作,而代理主题负责其他相关业务的处理. 相当于我玩一个游戏需要登录游戏,在这个登录的时候可以设计两个类,一个是登录,另一个是检验你的用户名与密码,而登录是附着在检验类上的. 设计模式-------适配器设计 对于

JUC源码分析-集合篇(三)ConcurrentLinkedQueue

JUC源码分析-集合篇(三)ConcurrentLinkedQueue 在并发编程中,有时候需要使用线程安全的队列.如果要实现一个线程安全的队列有两种方式:一种是使用阻塞算法,另一种是使用非阻塞算法.使用阻塞算法的队列可以用一个锁(入队和出队用同一把锁)或两个锁(入队和出队用不同的锁)等方式来实现.非阻塞的实现方 式则可以使用循环 CAS 的方式来实现.本节让我们一起来研究一下 Doug Lea 是如何使用非阻塞的方式来实现线程安全队列 ConcurrentLinkedQueue 的,相信从大师

JUC源码分析-集合篇(五)BlockingQueue 阻塞式队列实现原理

JUC源码分析-集合篇(五)BlockingQueue 阻塞式队列实现原理 以 LinkedBlockingQueue 分析 BlockingQueue 阻塞式队列的实现原理. 1. 数据结构 LinkedBlockingQueue 和 ConcurrentLinkedQueue 一样都是由 head 节点和 last 节点组成,每个节点(Node)由节点元素(item)和指向下一个节点(next)的引用组成,节点与节点之间就是通过这个 next 关联起来,从而组成一张链表结构的队列.默认情况下

JUC源码分析-集合篇(七)PriorityBlockingQueue

JUC源码分析-集合篇(七)PriorityBlockingQueue PriorityBlockingQueue 是带优先级的无界阻塞队列,每次出队都返回优先级最高的元素,是二叉树最小堆的实现. PriorityBlockingQueue 数据结构和 PriorityQueue 一致,而线程安全性使用的是 ReentrantLock. 1. 基本属性 // 最大可分配队列容量 Integer.MAX_VALUE - 8,减 8 是因为有的 VM 实现在数组头有些内容 private stati