面向对象，集合篇（1）

最新推荐文章于 2024-01-03 10:16:23 发布

Mr_Grizzly

最新推荐文章于 2024-01-03 10:16:23 发布

阅读量1.5k

点赞数 1

分类专栏：学习日志 Java学习日志文章标签：面向对象集合框架

本文链接：https://blog.csdn.net/xionghui2013/article/details/47617219

版权

学习日志同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

Java学习日志

10 篇文章 0 订阅

订阅专栏

一、集合的概念

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

我们以前用来存储对象使用的自己用数组写的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);
		}
	}
}

结果：