Java笔记 集合框架

变量：存储数据的容器，只能存储一个数据
数组：存储数据的容器，存储多个相同类型的数据
集合：存储数据的容器，存储多个不同类型的数据

集合框架：如果并不知道程序运行时会需要多少对象，或者需要 更复杂方式存储对象——可以使用Java集合框架

Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中，如下图，这里主要讲述ArrayList、LinkedList、HashSet、HashMap

 Collection 接口存储一组 不唯一，无序的对象

                

public class NewsTitle {
	private int id;
	private String name;
	private String author;
	
	public NewsTitle() {
		super();
	}
 
	public NewsTitle(int id, String name, String author) {
		super();
		this.id = id;
		this.name = name;
		this.author = author;
	}
 
	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 getAuthor() {
		return author;
	}
 
	public void setAuthor(String author) {
		this.author = author;
	}
 
	@Override
	public String toString() {
		return "NewsTitle [id=" + id + ", name=" + name + ", author=" + author
				+ "]";
	}		
}

List 接口存储一组不唯一，有序（插入顺序）的对象

        ArrayList实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高

                                                        ArrayList常用方法

import java.util.ArrayList;
import java.util.Iterator;
 
public class Test {
 
	public static void main(String[] args) {
		
		NewsTitle nt1=new NewsTitle(001,"合肥又发现一名新冠肺炎感染者","合肥日报");
		NewsTitle nt2=new NewsTitle(001,"合肥近日多天有雨","合肥气象局");
		NewsTitle nt3=new NewsTitle(001,"震惊！有一程序员猝死","张三");
		
		//定义一个集合，调用ArrayList类的无参的构造方法,默认构造一个初始容量为 10 的空列表。
		ArrayList al=new ArrayList();
		
		//将新闻标题的对象存储到al集合中
		al.add(nt1);
		al.add(nt2);
		al.add(nt3);
		
		//获取新闻标题的总数，即获取集合中的元素个数
		int num=al.size();
		System.out.println("新闻的标题总数为"+num);
		
		//void add(int index,Object o):在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之
		al.add(0, nt3);
		NewsTitle news =(NewsTitle)al.get(1);
		System.out.println("获取元素："+news);
		
		//boolean contains(Object o):判断列表中是否存在指定元素，如果集合中存在你要找的元素，返回true，否则返回false
		boolean result1=al.contains(nt3);
		System.out.println("集合中你需要找到的元素nt3:"+result1);
		
		//boolean remove(Object o):从列表中删除元素，删除成功返回true，删除失败返回false
		boolean result2=al.remove(nt2);
		System.out.println("删除是否成功："+result2);
						
		//toArray():将集合变成数组
		Object[] obj3  =al.toArray();
		for (int i = 0; i < obj3.length; i++) {
			System.out.println("转换成数组："+obj3[i]);
		}
		System.out.println("------------------");
		for(Object ob:al){
			NewsTitle nt = (NewsTitle)ob;
			System.out.println(nt);
		}
		
		Object remove(int index):从列表中删除指定位置元素，起始索引位置从0开始
//		Object obj1=al.remove(0);
//		NewsTitle newsTitle1=(NewsTitle)obj1;
//		System.out.println(newsTitle1);
		
		//遍历打印出每个新闻的名称
		for(int i=0;i<al.size();i++){
			Object obj=al.get(i);
			NewsTitle newsTitle=(NewsTitle)obj;
			System.out.println(newsTitle.getName());
		}
		
		//清除集合所有的元素
//		al.clear();
		
//		al.clone();
					
		//判断是否为空
		boolean result=al.isEmpty();
		System.out.println(result);		
		
		//iterator():迭代器（遍历），将集合中的元素“转移”到了迭代器这么一个容器中，接下来对迭代器容器进行遍历
		Iterator it =al.iterator();
		//遍历it这个容器，先使用hasNext()方法判断容器中是否有元素，有，使用next()方法取出，然后再判断，如果有，就取出元素，继续再判断，有，继续取出
		//it.hasNext():判断迭代器中是否有元素，如果有元素返回true
		while(it.hasNext()){
			//取出元素
			Object object =it.next();
			NewsTitle nt = (NewsTitle)object;
			System.out.println(nt);
		}		
	}
}

        LinkedList采用链表存储方式，插入、删除元素时效率比较高

                                                 LinkedList常用方法

import java.util.LinkedList;
 
public class Test {
 
	public static void main(String[] args) {
 
		// 准备集合中的内容，创建3个NewsTitle类对象
		NewsTitle nt1 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三");
		NewsTitle nt2 = new NewsTitle(1002, "合肥将变成一个没有传销的城市", "李四");
		NewsTitle nt3 = new NewsTitle(1003, "合肥比亚迪即将建成开厂", "王五");
		NewsTitle nt4 = new NewsTitle(1004, "大湖名城，创新高低", "赵六");
		NewsTitle nt5 = new NewsTitle(1005, "大湖名城，创新高低", "孙七");
		
		//准备容器，创建LinkedList对象
		LinkedList list = new LinkedList();
		list.addLast(nt5);
		list.add(nt1);
		list.add(nt2);
		list.add(nt3);		
		list.addFirst(nt4);
				
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		System.out.println("-----------------");		
		System.out.println(list.getFirst());
		System.out.println(list.getLast());
		
		System.out.println("-----------------");
		list.removeFirst();
		list.removeLast();
		for (Object object : list) {
			System.out.println(object);
		}
	}
}

Set 接口存储一组唯一，无序的对象

import java.util.HashSet;
import java.util.Iterator;
 
public class Test {
 
	public static void main(String[] args) {
		//准备数据：创建NewsTitle对象
		NewsTitle nt1 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三");
		NewsTitle nt2 = new NewsTitle(1002, "合肥将变成一个没有传销的城市", "李四");
		NewsTitle nt3 = new NewsTitle(1003, "合肥比亚迪即将建成开厂", "王五");
		NewsTitle nt4 = new NewsTitle(1004, "大湖名城，创新高低", "赵六");
		NewsTitle nt5 = new NewsTitle(1005, "大湖名城，创新高低", "孙七");
		
		//准备容器
		HashSet hs=new HashSet();
		hs.add(nt1);
		hs.add(nt2);
		hs.add(nt3);
		hs.add(nt4);
		hs.add(nt5);
		hs.add(nt3);
		hs.add(nt3);
		System.out.println(hs.size());
		
		for (Object object : hs) {
			System.out.println(object);
		}
		System.out.println("--------------------");
		Iterator it=hs.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			NewsTitle nt=(NewsTitle)obj;
			System.out.println(nt);
		}
	}
}

Map接口存储一组键值对象，提供key到value的映射 

                                                        Map接口常用方法

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class Test {
 
	public static void main(String[] args) {
		//准备键值对容器用来存储键值
		HashMap hm=new HashMap();
		
		//向集合中存储数据
		hm.put("CN", "中华人民共和国");
		hm.put("RU", "俄罗斯联邦");
		hm.put("US", "美利坚共和国");
		hm.put("JP", "小日本");
 
		System.out.println(hm.size());
		
		Object obj1=hm.get("CN");
		String str1=(String)obj1;
		System.out.println(str1);
		
		//Object remove(key):根据键来删除键值对，返回值是键对应的值
		Object obj2=hm.remove("JP");
		String str2=(String)obj2;
		System.out.println(hm.size());
		
		System.out.println(hm.containsKey("CN"));
		System.out.println(hm.containsKey("JP"));
		
		System.out.println(hm.containsKey("中华人民共和国"));
		
		//keySet():返回集合中所有键值对的键的集合
		Set keys=hm.keySet();
		for (Object obj3 : keys) {
			String key=(String)obj3;
			Object obj4=hm.get(key);
			String value=(String)obj4;
			System.out.println();
			System.out.println(key+"-"+value);
		}
		//Collection values():获取值得集合
		Collection coll=hm.values();
		for (Object object : coll) {
			String value =(String)object;
			System.out.println(value);
		}
		
		System.out.println("---------------------");
		//获取键的集合
		Set keys2=hm.keySet();
		Iterator it=keys2.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			String key=(String)obj;
			Object obj5=hm.get(key);
			String value =(String)obj5;
			System.out.println(key+"-"+value);
		}
		
		System.out.println("------------------------");
		//使用键值对的方式取出集合中的键值对
		Set keyValues=hm.entrySet();
		Iterator iterator=keyValues.iterator();
		while(iterator.hasNext()){
			Object obj =iterator.next();
			Map.Entry me = (Map.Entry)obj;
			Object obje1 = me.getKey();
			String key =(String)obje1;
			Object obje2 =me.getValue();
			String value =(String)obje2;
			System.out.println(key+"-"+value);
		}		
	}
}