Java集合框架

最新推荐文章于 2024-04-12 09:06:14 发布

忆丶长安

最新推荐文章于 2024-04-12 09:06:14 发布

阅读量124

点赞数 1

文章标签： java 哈希算法

本文链接：https://blog.csdn.net/vn666/article/details/125525178

版权

简介:

集合框架:用于存储数据的容器

变量:储存数据的容器,只能存储一个数据

数组:储存数据的容器,存储多个相同类型的数据

集合:储存数据的容器.存储多个不同类型的数据

Java集合框架:

Collection接口(不唯一,无序)

List,set

List:(不唯一,有序)

ArrayList,LinkedList

Set:(唯一,有序)

HashSet,TreeSet

Map:(键唯一,值不唯一)

HashMap,TreeMap

优点:

容量可以一直增加,不像数组那样不易修改
提供了方便的查询,修改,增删
允许API之间的相互操作
提高代码的复用性和可操作性
可以直接使用JDK中自带的集合类

Iterator接口

迭代器,方便集合遍历

方法:

boolean

hasNext()

如果仍有元素可以迭代，则返回 true。

next()

返回迭代的下一个元素。

void

remove()

从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

List集合

有序,不唯一的集合

List的主要实现：ArrayList， LinkedList， Vector。

主要常见方法:

boolean	add(E e) 向列表的尾部添加指定的元素（可选操作）。
void	add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。
void	clear() 从列表中移除所有元素（可选操作）。
boolean	contains(Object o) 如果列表包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c) 如果列表包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o) 比较指定的对象与列表是否相等。
E	get(int index) 返回列表中指定位置的元素。
int	hashCode() 返回列表的哈希码值。
boolean	isEmpty() 如果列表不包含元素，则返回 true。
Iterator<E>	iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。
E	remove(int index) 移除列表中指定位置的元素（可选操作）。
boolean	remove(Object o) 从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
E	set(int index, E element) 用指定元素替换列表中指定位置的元素（可选操作）。
int	size() 返回列表中的元素数。
Object[]	toArray() 返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
<T> T[]	toArray(T[] a) 返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

public class NewsTitle {
	private int id;
	private String name;
	private String content;
	
	public NewsTitle(int id, String name, String content) {
		super();
		this.id = id;
		this.name = name;
		this.content = content;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	@Override
	public String toString() {
		return "NewsTitle [content=" + content + ", id=" + id + ", name="
				+ name + "]";
	}
	
}
import java.util.LinkedList;

public class Test {
	/*
	 新闻管理系统，需求如下
	可以添加头条新闻标题
	获取头条和最末条新闻标题
	可以删除末条新闻标题
	*/
	public static void main(String[] args) {
		//创建三个NewsTitle对象
		NewsTitle nt1=new NewsTitle(1001, "张三", "ph真帅");
		NewsTitle nt2=new NewsTitle(1002, "李四", "ph真酷");
		NewsTitle nt3=new NewsTitle(1003, "王二", "ph真猛");
		NewsTitle nt4=new NewsTitle(1004, "王二", "ph真剎");
		
		//准备容器.创建LinkedList集合对象
		LinkedList<NewsTitle> list=new LinkedList<NewsTitle>();
		list.add(nt1);
		list.add(nt2);
		list.add(nt3);
		
		for (Object object:list) {
			System.out.println(object);
		}
		list.addFirst(nt4);
		
		
		System.out.println("-----------------");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		//删除指定位置元素
		System.out.println("-----------------");
		list.remove(3);
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		//判断列表中是否存在指定元素
		System.out.println("-----------------");
		boolean bool=list.contains(nt3);
		System.out.println("存在第四个信息"+bool);
	}

}

运行结果:

NewsTitle [content=ph真帅, id=1001, name=张三]
NewsTitle [content=ph真酷, id=1002, name=李四]
NewsTitle [content=ph真猛, id=1003, name=王二]
-----------------
NewsTitle [content=ph真剎, id=1004, name=王二]
NewsTitle [content=ph真帅, id=1001, name=张三]
NewsTitle [content=ph真酷, id=1002, name=李四]
NewsTitle [content=ph真猛, id=1003, name=王二]
-----------------
NewsTitle [content=ph真剎, id=1004, name=王二]
NewsTitle [content=ph真帅, id=1001, name=张三]
NewsTitle [content=ph真酷, id=1002, name=李四]
-----------------
存在第四个信息false

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

public class Test {
	/*
	 新闻管理系统，需求如下
	可以添加头条新闻标题
	获取头条和最末条新闻标题
	可以删除末条新闻标题
	*/
	public static void main(String[] args) {
		//创建三个NewsTitle对象
		NewsTitle nt1=new NewsTitle(1001, "张三", "ph真帅");
		NewsTitle nt2=new NewsTitle(1002, "李四", "ph真酷");
		NewsTitle nt3=new NewsTitle(1003, "王二", "ph真猛");
		NewsTitle nt4=new NewsTitle(1000, "王二", "ph真剎");
		
		//准备容器.创建ArrayList集合对象
		List<NewsTitle> list=new ArrayList<NewsTitle>();  //父类调用引向子类
		
		//将对象存储到集合中
		list.add(nt1);
		list.add(nt2);
		list.add(nt3);
		
		for (Object object : list) {
			System.out.println(object);
		}
		
		System.out.println("------------------");
		//添加头条新闻
		list.add(0, nt4);
		for (Object object : list) {
			System.out.println(object);
		}
		
		//获取头条和最末条新闻
		System.out.println("头条新闻是;"+list.get(0));
		System.out.println("最末条新闻是:"+list.get(list.size()-1));
		
		System.out.println("------------------");
		//删除末条新闻标题
		list.remove(list.size()-1);
		for (Object object : list) {
			System.out.println(object);
		}
	}

运行结果:
NewsTitle [content=ph真帅, id=1001, name=张三]
NewsTitle [content=ph真酷, id=1002, name=李四]
NewsTitle [content=ph真猛, id=1003, name=王二]
------------------
NewsTitle [content=ph真剎, id=1000, name=王二]
NewsTitle [content=ph真帅, id=1001, name=张三]
NewsTitle [content=ph真酷, id=1002, name=李四]
NewsTitle [content=ph真猛, id=1003, name=王二]
头条新闻是;NewsTitle [content=ph真剎, id=1000, name=王二]
最末条新闻是:NewsTitle [content=ph真猛, id=1003, name=王二]
------------------
NewsTitle [content=ph真剎, id=1000, name=王二]
NewsTitle [content=ph真帅, id=1001, name=张三]
NewsTitle [content=ph真酷, id=1002, name=李四]

Set集合

有序且唯一

主要方法:

boolean	add(E e) 如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
boolean	addAll(Collection<? extends E> c) 如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
void	clear() 移除此 set 中的所有元素（可选操作）。
boolean	contains(Object o) 如果 set 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c) 如果此 set 包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o) 比较指定对象与此 set 的相等性。
int	hashCode() 返回 set 的哈希码值。
boolean	isEmpty() 如果 set 不包含元素，则返回 true。
Iterator<E>	iterator() 返回在此 set 中的元素上进行迭代的迭代器。
boolean	remove(Object o) 如果 set 中存在指定的元素，则将其移除（可选操作）。
boolean	removeAll(Collection<?> c) 移除 set 中那些包含在指定 collection 中的元素（可选操作）。
boolean	retainAll(Collection<?> c) 仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
int	size() 返回 set 中的元素数（其容量）。
Object[]	toArray() 返回一个包含 set 中所有元素的数组。
<T> T[]	toArray(T[] a) 返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组

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

import com.bdqn.demo03.NewsTitle;

public class Test {
	
	public static void main(String[] args) {
		
		NewsTitle nt1=new NewsTitle(1001, "张三", "ph真帅");
		NewsTitle nt2=new NewsTitle(1002, "李四", "ph真酷");
		NewsTitle nt3=new NewsTitle(1003, "王二", "ph真猛");
		NewsTitle nt4=new NewsTitle(1004, "王二", "ph真剎");
		
		HashSet<NewsTitle> hs=new HashSet<NewsTitle>();
		hs.add(nt1);
		hs.add(nt2);
		hs.add(nt3);
		hs.add(nt4);
		hs.add(nt1);
		hs.add(nt3);
		hs.add(nt2);
		
		System.out.println(hs.size());
		for (Object object:hs) {
			System.out.println(object);//set是无序的不能使用get(下标)获取元素
		}
		
		System.out.println("-----------------");
		//使用迭代器中的hasNext()方法和next()方法遍历
		Iterator<NewsTitle> it=hs.iterator();
		while(it.hasNext()){
			Object ob= it.next();
			NewsTitle nt=(NewsTitle)ob;
			System.out.println(nt);
		}
	}

运行结果:
4
NewsTitle [content=ph真帅, id=1001, name=张三]
NewsTitle [content=ph真猛, id=1003, name=王二]
NewsTitle [content=ph真剎, id=1004, name=王二]
NewsTitle [content=ph真酷, id=1002, name=李四]
-----------------
NewsTitle [content=ph真帅, id=1001, name=张三]
NewsTitle [content=ph真猛, id=1003, name=王二]
NewsTitle [content=ph真剎, id=1004, name=王二]
NewsTitle [content=ph真酷, id=1002, name=李四]

Map集合

接口 Map<K,V>

类型参数：

K - 此映射所维护的键的类型

V - 映射值的类型

static interface

Map.Entry<K,V>

映射项（键-值对）。

void	clear() 从此映射中移除所有映射关系（可选操作）。
boolean	containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
boolean	containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>>	entrySet() 返回此映射中包含的映射关系的 Set 视图。
boolean	equals(Object o) 比较指定的对象与此映射是否相等。
V	get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int	hashCode() 返回此映射的哈希码值。
boolean	isEmpty() 如果此映射未包含键-值映射关系，则返回 true。
Set<K>	keySet() 返回此映射中包含的键的 Set 视图。
V	put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。
void	putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。
V	remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int	size() 返回此映射中的键-值映射关系数。
Collection<V>	values() 返回此映射中包含的值的 Collection 视图。

public class Student {
	private String name;
	private String sex;
	public Student(String name, String sex) {
		super();
		this.name = name;
		this.sex = sex;
	}
	public Student() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", sex=" + sex + "]";
	}
	
}

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

public class Test {

	public static void main(String[] args) {
	
		//创建两组Student的对象
		Student stu1=new Student("小明","男");
		Student stu2=new Student("小花","女");
		
		HashMap hm=new HashMap();
		
		//添加到Map中
		hm.put("Jack",stu1);
		hm.put("Rose",stu2);
		
		Object obj= hm.get("Rose");
		Student stu=(Student)obj;
		System.out.println("Rose对应的学员信息为：姓名:"+stu.getName()+"，性别："+stu.getSex());
		
		
		//遍历输出所有的学员的姓名和性别
		Set set=hm.entrySet();
		
		//增强for循环遍历
		for(Object object: set){
			Map.Entry me =(Map.Entry)object;
			Object obj1=me.getKey();
			String key=(String)obj1;//获取键值对应的值
			Object obj2=me.getValue();
			Student value=(Student)obj2;
			System.out.println(key+"对应的学员信息为：姓名:"+value.getName()+"，性别："+value.getSex());
			
		}
	}

}

运行结果:
Rose对应的学员信息为：姓名:小花，性别：女
Jack对应的学员信息为：姓名:小明，性别：男
Rose对应的学员信息为：姓名:小花，性别：女