Java集合(适合小白)

声明：本文为自己的笔记理解总结（说我抄书也没办法），其中优缺点为个人理解不喜勿喷

参考：书籍**《Java基础入门》2版**、JDK6.0帮助文档

一、Collection接口

Collextion是所有单列集合（List 和 Set）的根接口，在该接口中定义了单列集合的一些通用方法，这些方法能用来操作所有集合。

返回值	方法	注释
boolean	add(Object o)	像指定集合添加一个元素o
boolean	addAll(Collection c)	将指定元素集合c内的所有内容添加到该集合中
void	clear( )	删除该集合中所有元素
boolean	remove(Object o)	删除该集合中指定元素o
boolean	removeAll(Collection c)	删除该集合中所有与c集合相同的元素
boolean	retainAll(Collection c)	只保留该集合中与c相同的元素
boolean	isEmpty( )	判断该集合是否为空(空：true，非空：false)
boolean	contains(Object o)	判断该集合中是否包含元素o
boolean	containsAll(Collection c)	判断该集合中是否包含集合c（c中所有元素）
Iterator	iterator( )	返回在该集合的元素上进行迭代的迭代器（Iterator），用于遍历集合中的所有元素
int	size( )	返回该集合的元个数
Stream	stream( )	将集合源转换为有序元素的流对象
boolean	equals(Object o)	比较该集合是否与指定对像相等
Object [ ]	toArray( )	返回该集合中所有元素的数组
T[ ]	toArray(T[ ] a)	返回该集合中所有元素的数组，返回的数组与指定泛型数组类型相同

二、List接口

特点：允许重复，元素有序（存入和取出一致），通过索引能找到对应元素。

List接口新增方法

返回值	方法	注释
void	add(int index,Object o)	将元素o插入集合指定位置index
boolean	addAll(int index,Collection c)	将c集合中所有元素从index位置插入
Object	get(int index)	返回index索引位置的元素
Object	remove(int index)	删除index处的元素
Object	set(int index,Object o)	将索引index位置的元素替换成o，并将替换后的元素返回
int	indexOf(Object o)	返回对象o在集合中首次出现的索引位置
int	lastIndexOf(Object o)	返回对象o在集合中最后出现的索引位置
List	subList(int from,int to)	返回从from(包括)到to(不包括)处所有元素集合组成的子集合
Object[]	toArray( )	将集合元素转换为数组
default void	sort(Comparator<? super E> c)	根据指定的比较器规则对集合进行排序

1、 ArrayList集合

简介：ArrayList是List接口的实现类。是一个长度可变的数组对象，当长度超过原本分配内存长度的时候系统会自动寻找更大的内存空间，来存储这些元素。（可以将ArrayList集合看作是可变长的数组）

优点：采用索引访问元素，所以遍历数据较快

缺点：由于数据长度超过了的时候将重新分配内存空间所以插入和删除数据较慢，当需要经常插入删除数据的时候不建议使用ArrayList集合

特有方法

返回值	方法	注释
void	ensureCapacity(int min)	调整容量到最小能装下指定类型min个数的大小
void	trimToSize( )	将ArrayList实际容量调整为当前列表大小

包含包

import java.util.ArraList;

定义语法

//1
ArrayList [命名]=new ArrayList([大小]);
//2
ArrayList<泛型> [命名]=new ArrayList<泛型>([大小]);
//3
List [命名]=new ArrayList([大小]);
//4
List<泛型> [命名]=new ArrayList<泛型>([大小]);

注释：泛型可以是String、Integer、Character、Double等

实例演示（用到的Dog对象包含{String name；String strain}两个属性）

import java.util.ArrayList;
import java.util.List;//需要额外包含
//避免重复包含使用import java.util.*

public class ArrayList_Test {

	public static void main(String[] args) {
		//定义对象
        Dog dog1=new Dog("1号","哈士奇");
		Dog dog2=new Dog("2号","中华田园");
		Dog dog3=new Dog("3号","拉布拉多");
		Dog dog4=new Dog("4号","金毛");
		//定义集合
		List<Dog> home=new ArrayList<Dog>();
		//添加元素
		home.add(dog1);//顺序添加
		home.add(dog2);
		home.add(dog3);
		home.add(dog4);
		home.add(2, dog4);//指定位置添加元素
        //删除元素
		home.remove(0);//指定位置删除
		home.remove(dog4);//指定元素删除(删除第一个找到的)
        //使用索引(类似下标)遍历集合
		for(int i=0;i<home.size();i++) {
			Dog dog=(Dog)home.get(i);//如果添加了泛型可以省略强制类型转换
			System.out.println(dog.getStrain()+"狗狗"+dog.getName()+"正在吃骨头");
		}
        //contains(Object o)判断元素是否存在
		if(home.contains(dog4))System.out.println("yes");
		else System.out.println("no");
	}

}

输出结果

中华田园狗狗2号正在吃骨头
拉布拉多狗狗3号正在吃骨头
金毛狗狗4号正在吃骨头

2、LinkedList集合

简介:前面我们提到在ArrayList集合增加删除效率低，为此我们可以使用List另一个实现类LinkedList。该集合采用双向循环链表（参考C语言中利用结构体+指针生成的链表）可以通过一个元素找到上一个元素和下一个元素，对链表增加和删除的时候只需要改变连接的对象即可。

优点：采用双向链表形式存储，增加删除元素快，内存不要求连续性（个人猜测）

缺点：取元素没有ArrayList集合通过索引取快

特有方法

返回值	方法名	注释
void	add(int index,E element)	在指定位置插入指定元素
void	addFirst(Object o)	在链表头部插入元素
void	addLast(Object o)	在链表末尾插入元素
Object	getFirst( )	返回第一个元素
Object	getList( )	返回最后一个元素
Object	removeFirst( )	移除并返回第一个元素
Object	removeLast( )	移除并返回最后一个元素

boolean	offer(Object o)	将指定元素添加到集合尾
boolean	offerFirst(Object o)	将指定元素添加到集合头部
boolean	offerLast(Object o)	将指定元素添加到集合尾
Object	peek( )	获取集合的第一个元素
Object	peekFirst( )	获取集合的第一个元素
Object	peekLast( )	获取集合的最后一个元素
Object	poll( )	移除并返回集合第一个元素
Object	pollFirst( )	移除并返回集合第一个元素
Object	pollLast( )	移除并返回集合最后一个元素
void	push(Object o)	将指定元素添加到集合的开头
Object	pop( )	移除并返回集合的第一个元素
Object	clone( )	返回浅表副本

包含包

import java.util.LinkedList;

定义语法

//1
LinkedList [命名]=new LinkedList();
//2
LinkedList<泛型> [命名]=new LinkedList<泛型>();
//3
List [命名]=new LinkedList();
//4
List<泛型> [命名]=new LinkedList<泛型>();

实例演示

import java.util.LinkedList;
import java.util.List;

public class LinkedList_Test {
	
	public static void main(String[] args) {
        //定义对象
		Dog dog1=new Dog("1号","哈士奇");
		Dog dog2=new Dog("2号","中华田园");
		Dog dog3=new Dog("3号","拉布拉多");
		Dog dog4=new Dog("4号","金毛");
		//定义集合
		List<Dog> home=new LinkedList<Dog>();
		//添加元素
		home.add(dog1);
		home.add(dog2);
		home.add(dog3);
		home.add(dog4);
		//头部尾部添加元素(需要强制类型转换)
		((LinkedList<Dog>) home).addFirst(dog4);
		((LinkedList<Dog>) home).addLast(dog1);
        //通过迭代器遍历集合
		Iterator<Dog> iterator=home.iterator();
		while(iterator.hasNext()) {
			Dog dog=iterator.next();
			System.out.println(dog.getStrain()+"狗狗"+dog.getName()+"正在吃骨头");
		}
        //删除头部尾部元素(需要强制类型转换)
		((LinkedList<Dog>) home).removeFirst();
		((LinkedList<Dog>) home).removeLast();
        //获取头部尾部元素(需要强制类型转换)
		Dog dogFirst=(Dog)((LinkedList<Dog>) home).getFirst();
		System.out.println(dogFirst.name);
		Dog dogLast=(Dog)((LinkedList<Dog>) home).getLast();
		System.out.println(dogLast.name);
		
	}

}

输出结果

金毛狗狗4号正在吃骨头
哈士奇狗狗1号正在吃骨头
中华田园狗狗2号正在吃骨头
拉布拉多狗狗3号正在吃骨头
金毛狗狗4号正在吃骨头
哈士奇狗狗1号正在吃骨头
1号
4号

三、Set接口

特点：不允许重复

set接口新增方法

返回值	方法	注释
boolean	add(E e)	重写了方法，如果 set 中尚未存在指定的元素，则添加此元素

1、HashSet集合

简介：HashSet是set接口的实现类，它的所有存储单元是不可重复的，且元素也是无序的（更接近数学里面集合的概念）。自动调用hashCode( )方法确定元素存储位置，调用equals( )方法确保没有重复的元素。存取方式与List接口是一致的。

优点：自动无重复性

缺点：自动无重复性，因为是靠哈希码来确定无重复性的，所以添加的两个对象即使内容相同，但是由于是不同对象所以被认为是不同对象。

比如：stu1{id=1，name=“张三”}；stu2{id=1，name=”张三“}；stu1和stu2同样添加进集合是可以的（自行理解）；

特有方法：我晓得个锤锤

返回值	方法	注释
boolean	add(E e)	经过判断后，不添加重复

包含包

import java.util.HashSet;

定义语法

//1
HashSet [命名]=new HashSet();
//2
HashSet<泛型> [命名]=new HashSet<泛型>();
//3
Set [命名]=new HashSet([大小]);
//4
Set<泛型> [命名]=new HashSet<泛型>();

实例演示

import java.util.HashSet;
import java.util.Set;

public class HashSet_test {

	public static void main(String[] args) {
        //定义集合
		Set<String> set=new HashSet<String>();
        //插入对象
		set.add("123");
		set.add("234");
		set.add("345");
		set.add("123");//此处有重复插入
        //输出整个集合元素
		System.out.println("Set集合中的所有元素："+set);
		int i=1;
        //增强型循环遍历集合
		for(String a:set) {
			System.out.println(i+": "+a);
			i++;
		}
		
	}
	
}

输出结果

Set集合中的所有元素：[123, 234, 345]
1: 123
2: 234
3: 345

2、TreeSet集合

简介：实现类，内部采用平衡二叉树来存储元素，这样的结构可以保证TreeSet集合中没有重复的元素，并且可以对元素进行排序。（貌似依靠Comparable接口中的compareTo()方法进行比较）

优点：通过平衡二叉树存储数据避免了数据的重复性，可以有顺序

缺点：感觉不出

特有方法

返回值	方法	注释
Object	first( )	返回TreeSet集合的首个元素
Object	last( )	返回集合最后一个元素
Object	lower(Object o)	返回集合中小于给定元素最大的元素，没有就返回null
Object	floor(Object o)	返回集合中小于或等于给定元素最大的元素，没有就返回null
Object	higher(Object o)	返回集合中大于给定元素最小的元素，没有就返回null
Object	ceiling(Object o)	返回集合中大于或等于给定元素最小的元素，没有就返回null
Object	pollFirst( )	移除并返回集合的第一个元素
Object	pollLast( )	移除并返回集合的最后一个元素

包含包

import java.util.TreeSet;

定义语法

//1
TreeSet [命名]=new TreeSet();
//2
TreeSet<泛型> [命名]=new TreeSet<泛型>();
//3
Set [命名]=new TreeSet();
//4
Set<泛型> [命名]=new TreeSet<泛型>();

实例演示

import java.util.Set;
import java.util.TreeSet;

public class TreeSet_test {

	public static void main(String[] args) {
		Set<Integer> set=new TreeSet<Integer>();
		set.add(13);
		set.add(8);
		set.add(17);
		set.add(17);
		set.add(1);
		set.add(11);
		set.add(15);
		set.add(25);
		System.out.println(set);
		System.out.println(((TreeSet<Integer>) set).first());
		
	}

}

输出结果

[1, 8, 11, 13, 15, 17, 25]
1

亖、Map接口

Map接口是一种键(Key)–>值(Value)对应的双列集合接口（比如生活中的身份证号(Key)–>人(Value)一样）。其中Key值不可以重复，通过Key可以找到Value。

返回值	方法	注释
void	put(Object key,Object value)	像集合中添加键值映射元素
int	size( )	返回集合中的元素个数
Object	get(Object key)	返回键key所对应的值如果不包含映射关系返回null
boolean	containsKey(Object key)	查看集合中是否有指定键key
boolean	containsValue(Object value)	查看集合中是否存在指定对象value
Object	remove(Object key)	删除并返回集合中Key键映射的元素
void	clear( )	清空集合中的键值映射的元素
Set	keySet( )	以Set集合形式返回集合中所有的键对象
Collection	values( )	以Collection集合形式返回集合中的值对象

1、HashMap集合

简介：HashMap是Map接口的实现类，该集合键和值允许为空，但键不允许重复，且集合中的元素是无序的。HashMap底层是由哈希表构成的其实就是“数组+链表”的结合。

优点：增、删、改、查效率高。

缺点：不知

特有方法：无

包含包

import java.util.HashMap

定义语法

//1
HashMap [命名]=new HashMap();
//2
HashMap<泛型> [命名]=new HashMap<泛型>();
//3
Map [命名]=new HashMap();
//4
Map<泛型> [命名]=new HashMap<泛型>();

实例演示

import java.util.*;

public class HashMap_Test {

	public static void main(String[] args) {
		Map<String, String> countries=new HashMap<String, String>();
		countries.put("CN", "中华人民共和国");
		countries.put("US", "美利坚合众国");
		countries.put("FR", "法兰西共和国");
		countries.put("JP", "小日……子过得不错的日本");	
		
		String str=(String)countries.get("JP");
		System.out.println("JP对应的是："+str);
		
		System.out.println("Map集合中有"+countries.size()+"组数据");
		
		System.out.println(countries.remove("US")+"被删除了。");
		
		System.out.println("Map集合中是否包含-US:"+countries.containsKey("US"));
		
		System.out.println("键："+countries.keySet());
		System.out.println("值："+countries.values());
		
		System.out.println(countries);//直接输出名字对应的就是{键1=值1,键2=值2,键2=值2}
	}

}

结果输出

JP对应的是：小日……子过得不错的日本
Map集合中有4组数据
美利坚合众国被删除了。
Map集合中是否包含-US:false
键：[JP, CN, FR]
值：[小日……子过得不错的日本, 中华人民共和国, 法兰西共和国]
{JP=小日……子过得不错的日本, CN=中华人民共和国, FR=法兰西共和国}

2、TreeMap集合

简介：可以自动排序的无重复集合

优点：自动排序

缺点：不知

特有方法：无

包含包

import java.util.TreeMap

定义语法

//1
TreeMap [命名]=new TreeMap();
//2
TreeMap<泛型> [命名]=new TreeMap<泛型>();
//3
Map [命名]=new TreeMap();
//4
Map<泛型> [命名]=new TreeMap<泛型>();

实例演示

package map;

import java.util.*;

public class TreeMap_Test {

	public static void main(String[] args) {
		 SortedMap<Integer, String> map = new TreeMap<Integer, String>();//创建TreeMap实例对象
	        map.put(3,"John");
	        map.put(2, "Tome");
	        map.put(1,"Todd");
	        map.put(5,"Jane");
	        map.put(4, "William");//新添加一个元素，sortedMap将会自动排序
	    for(Object k : map.keySet()){//以for-each语句对sortedMap集合进行遍历
	            System.out.println(k + ":" + map.get(k));
	    }
	}

}

结果输出

1:Todd
2:Tome
3:John
4:William
5:Jane

3、Properties集合

简介：基本被HashMap集合取代

Chengyu1012

原创文章 11 获赞 7 访问量 459

关注私信