1、集合的概述
（1）集合、数组都是对多个数据进行存储操作的结构，简称 Java 容器。

说明：此时的存储，主要是指能存层面的存储，不涉及到持久化的存

储（.txt,.jpg,.avi, 数据库中）。

（2）数组在存储多个数据封面的特点：

1）一旦初始化以后，它的长度就确定了。

2）数组一旦定义好，它的数据类型也就确定了。我们就只能操作指定类型的数据了。比如：String[] arr; int[] arr1; Object[] arr2。

（3）数组在存储多个数据方面的缺点：

1）一旦初始化以后，其长度就不可修改。

2）数组中提供的方法非常有限，对于添加、删除、插入数据等操作，

非常不便，同时效率不高。

3）获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。

4）数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足

（4）Java 集合可分为 Collection 和 Map 两种体系：

Collection 接口：单列数据，定义了存取一组对象的方法的集合。

List：元素有序、可重复的集合。

Set：元素无序、不可重复的集合。

Map 接口：双列数据，保存具有映射关系“key-value 对”的集合。

2、集合框架
（1）Collection 接口：单列集合，用来存储一个一个的对象

1）List 接口：存储有序的、可重复的数据。

ArrayList、LinkedList

2）Set 接口：存储无序的、不可重复的数据

HashSet、LinkedHashSet、TreeSet

（2）Map 接口：双列集合，用来存储一对一对的数据

HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

3、List接口

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

（2）ArrayList

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

2）说明：

ArrayList类是List接口的一个具体实现类

ArrayList对象实现了可变大小的数组

随机访问和遍历元素时，它提供更好的性能

3）ArrayList常用方法

方法	说明
boolean add(Object o)	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)	在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size()	返回列表中的元素个数
Object get(int index)	返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
boolean remove(Object o)	从列表中删除元素
Object remove(int index)	从列表中删除指定位置元素，起始索引位置从0开始

4）举例

例1:

NewsTitle:

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

Test1:

import java.util.ArrayList;

public class Test1 {
	public static void main(String[] args) {
		//创建3个新闻标题类对象
		NewsTitle nt1 = new NewsTitle(1001, "合肥新站区和肥西各新增1例新冠肺炎感染者", "合肥日报");
		NewsTitle nt2 = new NewsTitle(1002, "合肥今日有暴雨，局部地区特大暴雨", "张三");
		NewsTitle nt3 = new NewsTitle(1003, "震惊，程序员每天竟然喜欢干这件事", "李四");
		// 准备集合容器，调用ArrayList类的无参构造方法，创建一个默认长度为10的集合容器
		ArrayList al = new ArrayList();
		
		// 将创建的新闻标题对象存储到al集合中
		al.add(nt1);
		al.add(nt2);
		al.add(nt3);
		
		// 获取新闻标题的总数----》获取集合中元素的个数
		int size = al.size();
		System.out.println("集合中元素个数为"+size);
		
		//获取新闻标题名称
		Object obj1 = al.get(0);
		NewsTitle nT1 = (NewsTitle) obj1;//向下转型
		String ntName1 = nt1.getName();
		System.out.println(ntName1);
		
		//通过循环输出所有新闻标题名称
		for(int i = 0;i

Test2:简化步骤

import java.util.ArrayList;
public class Test2 {
	public static void main(String[] args) {
		
		// 准备集合容器，调用ArrayList类的无参构造方法，创建一个默认长度为10的集合容器
		ArrayList al = new ArrayList();
		
		// 将创建的3个新闻标题对象存储到al集合中	
		al.add(new NewsTitle(1001, "合肥新站区和肥西各新增1例新冠肺炎感染者", "合肥日报"));
		al.add(new NewsTitle(1002, "合肥今日有暴雨，局部地区特大暴雨", "张三"));
		al.add(new NewsTitle(1003, "震惊，程序员每天竟然喜欢干这件事", "李四"));
		
		// 获取新闻标题的总数----》获取集合中元素的个数
		int size = al.size();
		System.out.println("集合中元素个数为"+size);
		
		//获取新闻标题名称
		Object obj1 = al.get(0);
		NewsTitle nTitle1 =(NewsTitle)obj1;
		String titleName = nTitle1.getName();
		System.out.println(titleName);
		
		//通过循环输出所有新闻标题名称
		for(int i = 0;i

Test3:利用对象数组

public class Test3 {
	public static void main(String[] args) {
		//创建新闻标题对象数组
		NewsTitle[] nTitle = new NewsTitle[3];
		//数组元素赋值
		nTitle[0] = new NewsTitle(1001, "合肥新站区和肥西各新增1例新冠肺炎感染者", "合肥日报");
		nTitle[1] = new NewsTitle(1002, "合肥今日有暴雨，局部地区特大暴雨", "张三");
		nTitle[2] = new NewsTitle(1003, "震惊，程序员每天竟然喜欢干这件事", "李四");
		
//		//创建新闻标题对象
//		NewsTitle new1 = new NewsTitle(1001, "合肥新站区和肥西各新增1例新冠肺炎感染者", "合肥日报");
//		//把对象放进对象数组中
//		nTitle[0] = new1;
//		//上面两步可以卸载一起
//		nTitle[0] = new NewsTitle(1001, "合肥新站区和肥西各新增1例新冠肺炎感染者", "合肥日报");
		
		//获取数组元素个数
		int length = nTitle.length;
		System.out.println("数组中元素个数为"+nTitle.length);
		
		//获取新闻标题名称
		String titleName1 = nTitle[0].getName();
		System.out.println(titleName1);
		
		//通过循环输出所有新闻标题名称
		for(int i = 0; i 
例2： 
NewsTitle:同上 
Test： 
import java.util.ArrayList;
import java.util.Iterator;

public class Test {
	public static void main(String[] args) {
		
		//创建3个新闻标题类对象
		NewsTitle nt1 = new NewsTitle(1001, "合肥新站区和肥西各新增1例新冠肺炎感染者", "合肥日报");
		NewsTitle nt2 = new NewsTitle(1002, "合肥今日有暴雨，局部地区特大暴雨", "张三");
		NewsTitle nt3 = new NewsTitle(1003, "震惊，程序员每天竟然喜欢干这件事", "李四");
		NewsTitle nt4 = new NewsTitle(1004, "安徽泗县昨日新增新冠肺炎无症状感染者23例", "安徽日报");
		
		// 准备集合容器，调用ArrayList类的无参构造方法，创建一个默认长度为10的集合容器
		ArrayList al = new ArrayList();
		
		// 将创建的新闻标题对象存储到al集合中
		al.add(nt1);
		al.add(nt2);
		al.add(nt3);
		
		// 获取新闻标题的总数----》获取集合中元素的个数
		//int size():返回列表中的元素个数
		int size = al.size();
		System.out.println("集合中元素个数为"+size);
		
		//获取新闻标题名称
		Object obj1 = al.get(0);
		NewsTitle nT1 = (NewsTitle) obj1;//向下转型
		String ntName1 = nt1.getName();
		System.out.println(ntName1);
		
		//通过循环输出所有新闻标题名称
		for(int i = 0;i 
例3： 
NewsTitle:同上 
Test： 
import java.util.ArrayList;
import java.util.List;
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, "大湖名城，创新高低", "赵六");
				
				
				//准备容器，创建ArrayList集合对象
				List list = new ArrayList();//父类的引用指向子类的实例
				
				//将对象元素存储到集合中
				list.add(nt1);
				list.add(nt2);
				list.add(nt3);
				//可以添加头条新闻标题
				list.add(0,nt4);
				//获取头条和最末条新闻标题
				System.out.println(list.get(0));
				System.out.println(list.get(list.size()-1));
				
				//可以删除末条新闻标题
				list.remove(list.size()-1);
				
				System.out.println("-------------");
				for (Object object : list) {
					System.out.println(object);
				}
	}
} 
（3）LinkedList 
1）LinkedList采用链表存储方式，插入、删除元素时效率比较高 
2）说明： 
LinkedList类是List接口的一个具体实现类 
LinkedList 类用于创建链表数据结构 
插入或者删除元素时，它提供更好的性能 
3）LinkedList常用方法 
 方法
  说明
 
 void  addFirst(Object o)
  在列表的首部添加元素
 
 void  addLast(Object o)
  在列表的末尾添加元素
 
 Object  getFirst()
  返回列表中的第一个元素
 
 Object  getLast()
  返回列表中的最后一个元素
 
 Object  removeFirst()
  删除并返回列表中的第一个元素
 
 Object  removeLast()
  删除并返回列表中的最后一个元素
 
4）举例 
例1： 
NewsTitle： 
public class NewsTitle {
	private int id;
	private String name;
	private String auther;
	public NewsTitle() {
		super();
	}
	public NewsTitle(int id, String name, String auther) {
		super();
		this.id = id;
		this.name = name;
		this.auther = auther;
	}
	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 getAuther() {
		return auther;
	}
	public void setAuther(String auther) {
		this.auther = auther;
	}
	@Override
	public String toString() {
		return "NewsTitle [ + id + ", name=" + name + ", auther=" + auther
				+ "]";
	}
} 
Test： 
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.add(nt1);
		list.add(nt2);
		list.add(nt3);
		list.addLast(nt5);
		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();
		
		System.out.println("--------------删除元素后进行遍历-------------");
		for (Object object : list) {
			System.out.println(object);
		}
	}
} 
4、Set接口 
（1）Set 接口存储一组唯一，无序的对象 
（2）HashSet是Set接口常用的实现类 
（3）遍历Set集合 
1）通过迭代器Iterator实现遍历 
Iterator的方法： 
boolean hasNext(): 判断是否存在另一个可访问的元素 
Object next(): 返回要访问的下一个元素 
2）增强型for循环 
（4）举例 
NewsTitle： 
public class NewsTitle {
	private int id;
	private String name;
	private String auther;
	public NewsTitle() {
		super();
	}
	public NewsTitle(int id, String name, String auther) {
		super();
		this.id = id;
		this.name = name;
		this.auther = auther;
	}
	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 getAuther() {
		return auther;
	}
	public void setAuther(String auther) {
		this.auther = auther;
	}
	@Override
	public String toString() {
		return "NewsTitle [ + id + ", name=" + name + ", auther=" + auther
				+ "]";
	}
} 
Test： 
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);
		
		System.out.println(hs.size());
		
		for (Object object : hs) {
			System.out.println(object);
		}
		System.out.println("________________________________________");
		Iterator it = hs.iterator();
		while(it.hasNext()){
			NewsTitle ne = (NewsTitle)it.next();
			System.out.println(ne);
		}				
	}
} 
5、Map接口 
（1）Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作（最常用的实现类是HashMap） 
（2）Map接口常用方法 
 方法
  说明
 
 Object put(Object key, Object val)
  以“键-值”对的方式进行存储
 
 Object get(Object key)
  根据键返回相关联的值，如果不存在指定的键，返回null
 
 Object remove(Object key)
  删除由指定的键映射的“键-值对”
 
 int size()
  返回元素个数
 
 Set keySet()
  返回键的集合
 
 Collection values()
  返回值的集合
 
 boolean containsKey(Object key)
  如果存在由指定的键映射的“键-值对”，返回true
 
（3）举例 
例1：Map方法 
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapMathod {
	public static void main(String[] args) {
		
		//准备键值对容器(Map集合)用来存储键值对
		HashMap hm = new HashMap();
		
		//向Map集合中存储数据
		hm.put("CN", "中华人民共和国");
		hm.put("RU","俄罗斯联邦");
		hm.put("US", "美利坚合众国");
		hm.put("JP", "日本");
		
		//集合大小
		System.out.println(hm.size());//4
		
		//获取key中对应value
		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;//返回值是键对应的值类型String
		System.out.println(str2);//日本
		//此时集合大小
		System.out.println(hm.size());//3
		
		System.out.println("-------------------");
		
		//boolean containsKey(Object key):如果存在由指定的键映射的“键-值对”，返回true
        boolean result1 = hm.containsKey("CN");
        boolean result2 = hm.containsKey("JP");
        System.out.println(result1);//true
        System.out.println(result2);//false
        
        System.out.println("-------------------");
        
        //boolean containsValue(Object value):如果存在由指定的value映射的“键-值对”，返回true
        boolean result3 = hm.containsValue("中华人民共和国");
        boolean result4 = hm.containsValue("日本");
        System.out.println(result3);//true
        System.out.println(result4);//false
        
        System.out.println("-------------------");
        
        //keySet():返回集合中所有键值对的键的集合
        Set set = hm.keySet();
        for (Object object : set) {
        	//获取键值
			String key = (String) object;
			//获取value
			Object obj3 = hm.get(key);
			String value = (String) obj3;
			System.out.println(key+"  "+value);
		}
        
        System.out.println("-------------------");
        
       //Collection values():获取值得集合
        Collection coll = hm.values();
        for (Object object : coll) {
			String value = (String)object;
			System.out.println(value);
		}
        
        System.out.println("-------------------");
        
       //iterator迭代器获取键的集合
        Set keys = hm.keySet();//获取集合中所有键值对的键的集合
        Iterator it = keys.iterator();
        while(it.hasNext()){
        	Object obj4 = it.next();
        	String key = (String) obj4;
        	Object obj5 = hm.get(key);
        	String value = (String) obj5;
        	System.out.println(key+"   "+value);
        }
        
        System.out.println("-------------------");
        
      //使用键值对的方式取出集合中的键值对
       Set keyValues =  hm.entrySet();//将集合中的键值对全部取出来存储到Set集合
       Iterator iterator = keyValues.iterator();//将Set集合中的元素存储到迭代器中
       while(iterator.hasNext()){
    	   Object obj = iterator.next();//使用next()方法获取迭代器中的元素
    	   Map.Entry me = (Map.Entry)obj;//键值对元素的类型为Map.Entry
    	   String key = (String)me.getKey();//键值对类型对象调用getKey()方法可以获取键值对的键
    	   String value = (String)me.getValue();//键值对类型对象调用getValue()方法可以获取键值对的值
    	   System.out.println(key+"  "+value);
       }	
	}
} 
例2： 
Student： 
public class Student {
	private String name;
	private String gender;
	public Student() {
		super();
	}
	public Student(String name, String gender) {
		super();
		this.name = name;
		this.gender = gender;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", gender=" + gender + "]";
	}
} 
Test： 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Test {
	public static void main(String[] args) {
		//创建学生对象
		Student stu1 = new Student("张三", "男");
		Student stu2 = new Student("李四","男");
		Student stu3 = new Student("如花", "女");
		
		//创建HashMap集合对象
		HashMap hm = new HashMap();
		
		//将学生对象添加到创建的集合中去
		hm.put("jack", stu1);
		hm.put("tom", stu2);
		hm.put("rous", stu3);
		
		//获取指定学生信息
		 Object obj = hm.get("jack");
		 Student stu = (Student) obj;
//		 String name = stu.getName();
//		 String gender = stu.getGender();
		 System.out.println("jack学员信息为：姓名"+stu.getName()+"，性别："+stu.getGender());
		 System.out.println("---------------------------------");
		 
		 //使用键值对的方式便利输出所有学员的姓名和性别
		 Set set = hm.entrySet();//将集合中的键值对全部取出来存储到Set集合
		 for (Object object : set) {
			Map.Entry me = (Entry) object;//键值对元素的类型为Map.Entry
			//获取键值对的键
			Object obj1 = me.getKey();
			String keys = (String)obj1;
			//获取键值对的值
			Object obj2 = me.getValue();
			Student student = (Student)obj2;
			System.out.println(keys+"学员信息为：姓名"+student.getName()+"，性别："+student.getGender());
		} 	
	}
}

笔记Day18

Java相关栏目本月热门文章

方法	说明
void addFirst(Object o)	在列表的首部添加元素
void addLast(Object o)	在列表的末尾添加元素
Object getFirst()	返回列表中的第一个元素
Object getLast()	返回列表中的最后一个元素
Object removeFirst()	删除并返回列表中的第一个元素
Object removeLast()	删除并返回列表中的最后一个元素

方法	说明
Object put(Object key, Object val)	以“键-值”对的方式进行存储
Object get(Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove(Object key)	删除由指定的键映射的“键-值对”
int size()	返回元素个数
Set keySet()	返回键的集合
Collection values()	返回值的集合
boolean containsKey(Object key)	如果存在由指定的键映射的“键-值对”，返回true