java集合类（新手也能掌握）

文章目录

• 1.集合概述
• • • （1）集合：
    • （2）集合分类:
• 2.Collection接口
• 3.List接口
• • • (1)List接口简介
    • （2）ArrayList集合
    • （3）LinkedList集合
    • （4）Iterater接口
    • （5）foreach循环
• 4.Set接口
• • • （1）Set接口简介
    • （2）HashSet集合
• 5.Map接口
• • • （1）Map接口简介
    • （2）HashMap集合
    • （3）Properties集合
• 6.泛型---JDK5.0新特性

1.集合概述

（1）集合：

为了在程序中可以保存数目不确定的对象，JDK中在java.util包中提供了一系列可以存储任意类型的对象且长度可变的特殊类，在JAVA中这些类即集合类。

（2）集合分类:

集合按其存储结构可以分为两大类，即单列集合Collection和双列集合Map!

2.Collection接口

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set)通用的方法，即：

注：此处列出的方法仅为部分，初学者可以查阅API文档学习更多。

3.List接口

(1)List接口简介

List接口继承自Collection接口（单列），实现了List接口的对象即List集合。
List集合的特点：元素以线性方式进行存储且通过索引来访问指定元素 元素可重复 元素有序即元素的存入与取出的顺序一致。
List的方法：List除了继承自Collection接口的方法，还根据元素索引增加了一些特有的方法 即：

（2）ArrayList集合

ArrayList是List接口的一个实现类，可看作一个长度可变的数组，因其内部封装了一个长度可变的数组对象，当元素超过数组长度时，ArrayList会在内存中分配一个更大的可变数组来存储元素。
ArrayList方法大部分继承自Collection和List。

当通过索引对集合进行操作时，特别注意集合与数组一样，索引的取值范围是从0开始的，最后一个索引是size-1

ArrayList优点：查找元素很方便
ArrayList缺点：对元素进行增删改操作效率比较低

采用索引的方式来访问元素，使得ArrayList集合查找元素很方便
ArrayList集合的底层是使用数组来存储元素的，因此在对集合进行修改操作时，集合会创建一个新的数组。具体如图：

（3）LinkedList集合

为克服ArrayList集合对集合元素进行修改效率低的局限性，List接口中存在另一个实现类LinkedList。
该集合以双向环链表方式存储元素，当增加一个新元素时，只需要修改元素之间的这种引用关系即可，因此LinkedList集合对集合元素进行增删改操作效率高。
如图：

对于元素的增删操作，LinkedList集合定义了一些特有的方法

（4）Iterater接口

Iterator接口是Java集合中主要用于遍历（迭代访问）Collection中的元素的接口，Iterator对象被称为迭代器。
工作原理:集合调用iterator()方法获得迭代器对象，随后使用hasNext（）方法判断集合中是否存在下一个元素，若存在则调用next()方法获取元素，否则停止遍历元素。
在Iterator遍历内部对数组元素进行更改:
①集合对象.remove(变量名); break;
②Iterator游标名.remove();

（5）foreach循环

foreach循环(增强for循环)：语法非常简洁，每次循环时，foreach中都通过变量将当前循环的元素记住，从而将集合中的元素分别打印出来。因此foreach循环不需要获取容器的长度，也不需要根据索引访问容器中的元素。
语法:for(容器中元素类型 临时变量：容器变量）{ 执行语句 }
foreach循环不能对其中元素进行修改，for循环通过索引方式可以。

4.Set接口

（1）Set接口简介

与List接口一样，Set接口也继承Collection接口的方法，
与List接口不同，Set接口中元素无序且不重复。
Set接口主要实现类：HashSet和TreeSet。
HashSet根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。TreeSet则是以二叉树的方式来存储元素，它可以实现对集合中的元素进行排序。

（2）HashSet集合

工作原理：

实际开发中为保证HashSet正常工作，都需要重写Object类中的hashCode()和equals()方法
示例如下：

package homework_set;
import java.util.*;
	class Person{//自定义Person类
		private String name;
		private String card;

	public Person(String name,String card){//构造方法调用私有属性
			this.name=name;
			this.card=card;
	}

		//重写hashCode方法
	public int hashCode(){
		return name.hashCode();//以用户名作为判断重复依据
	}
		//重写equals方法
	public boolean equals(Object obj){
		if(this==obj){//判断是否同一个对象
			return true;//如果是同一个对象，直接返回true
		}
		if(obj==null){//判断这个对象是否为空
			return false;//如果对象是空的，直接返回false
		}
		if(getClass()!=obj.getClass()){//判断这个对象是否是Person类型
			return false;//如果不是，直接返回false
		}
		Person other=(Person)obj;//将对象强转为Person类型
		if(name==null){//判断集合中用户名是否为空
			if(other.name!=null){//判断对象中的用户名是否为空
				return false;//集合中用户名为空且对象中用户名不为空，则返回false
			}
		}else if(!name.equals(other.name)){//判断用户名是否相同
			return false;//如果不同，返回false
		}
		return true;
	}
		//重写toString方法
	public String toString(){
		return name+":"+card;
	}
	}
	public class set{
	public static void main(String[] args) {//创建集合和对象
		HashSet a=new HashSet();
		try{
		Person person1=new Person("李先生","220186");
		Person person2=new Person("马先生","220181");
		Person person3=new Person("李先生","220187");
		Person person4=new Person("王小姐","220193");
			//向集合添加元素
			a.add(person1);
			a.add(person2);
			a.add(person3);
			a.add(person4);
			for(Object b:a){//遍历输出集合元素
				System.out.println(b);
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

5.Map接口

（1）Map接口简介

Map接口是一种双列集合，具有映射关系，即：每一个元素都包含一个键对象Key和值对象Value，访问元素时只需指定Key就能找到对应的Value.
以下为map接口中常用方法：

（2）HashMap集合

HashMap集合是Map接口的一个实现类，用于存储键值映射关系，且保证不出现重复的键。

遍历map集合的三种方法：
方法一：

通过KeySet()方法获取Map中所有键的Set集合然后遍历所有键，再调用get()方法获取对应值

package course;
import java.util.*;
public class map2 {
	public static void main(String[] args) {
		Map map=new HashMap();//创建HashMap
		//添加对象，键值对，键Integer类型，值String类型
		map.put(4,"four");
		map.put(9,"nine");
		map.put(8,"eight");
		map.put(9, "nine1");//键相同，值覆盖
		//显示集合
		System.out.println(map);
		//方法一：
		Set keySet=map.keySet();//去重 无序
		Iterator it = keySet.iterator();//获取迭代器对象
		while(it.hasNext()){
		Object key=it.next();
		Object value= map.get(key);
		System.out.println(key+":"+value);
	}
	}
}

方法二：

先获取集合中所有的映射关系，然后从映射关系中取出键和值

package course;
import java.util.*;
public class map3 {
	public static void main(String[] args) {
		//方法二：
		Map map=new HashMap();
		//添加对象，键值对，键Integer类型，值String类型
		map.put(4,"four");
		map.put(9,"nine");
		map.put(8,"eight");
		Set entrySet=map.entrySet(); //调用Map对象的entrySet()方法获得存储在Map中所有映射的Set集合
		Iterator it=entrySet.iterator(); //获取迭代器对象
		while(it.hasNext()){ //迭代Set集合，获得每个映射对象
			Map.Entry entry=(Map.Entry)(it.next());  //Set集合中存放的Map.Entry对象，代表Map中的一个键值对
			Object Key=entry.getKey(); //调用getKey()方法获取Entry中的键
			Object Value=entry.getValue(); //调用getValue()方法获取Entry中的值
			System.out.println(Key+":"+Value);
		}
	}

}

方法三：

通过Map中values()方法，直接获取Map中存储所有值的Collection集合

package course;
import java.util.*;
public class map4 {
	public static void main(String[] args) {
		Map map=new HashMap();
		map.put(4,"four");
		map.put(9,"nine");
		map.put(8,"eight");
		Collection values=map.values();
		Iterator it=values.iterator();
		for(Object value:values){
			System.out.println(value);
		}
	}
}

LinkedHashMap:
LinkedHashMap是HashMap的子类，与LinkedList一样，内部以双向链表来维护内部元素的关系，使Map元素迭代的顺序与存入的顺序一致。
示例：

package course;
import java.util.*;
public class map5 {
	public static void main(String[] args) {
		HashMap map=new LinkedHashMap();
		map.put(4,"four");
		map.put(9,"nine");
		map.put(8,"eight");
		Set keySet=map.keySet();//去重 无序
		Iterator it = keySet.iterator();//获取迭代器对象
		while(it.hasNext()){
		Object key=it.next();
		Object value= map.get(key);
		System.out.println(key+":"+value);
	}
	}
}

（3）Properties集合

Map接口中还有一个实现类Hashtable,它与HashMap十分相似，区别在于Hashtable是线程安全的，但Hashtable存取元素时速度很慢，目前基本上被HashMap类取代，但Hashtable之类Properties，在实际应用中非常重要。

示例：

package course;
import java.util.*;
public class Properties1 {
	public static void main(String[] args) {
		Properties p = new Properties(); //创建Properties集合
		p.setProperty("Backgroup-color","green"); //存储键值对（如：put（）)
		p.setProperty("Font-size","14px");
		p.setProperty("Language","English");
		//获取集合中所有的键
		Enumeration names=p.propertyNames(); //Enumeration(相当于iterator迭代器)
		//遍历键的集合，获取每一个键
		while(names.hasMoreElements()){ //hasMoreElements()相当于hasNext()
			String Key=(String)names.nextElement(); //获取键 nextElement()相当于next()
			String value=p.getProperty(Key);  //获取值
			System.out.println(Key+"="+value);
		}
	}
}

6.泛型—JDK5.0新特性

当将任意类型的对象存入集合后，集合便会”忘记“对象的类型，因此取出元素时如果进行强制类型转换就会出错。为解决此问题java引入泛型概念，即：限定集合元素类型。在定义集合类时，使用”<参数类型>“的方式指定该类方法操作的数据类型。

LinkedList<参数类型> List = new LinkedList<参数类型>();

注意在使用泛型后，每次遍历集合元素时，可以指定该元素类型为”参数类型"