Java容器及其相关学习记录

发表于 分类于 阅读次数： 本文字数： 2.3k 阅读时长 ≈ 8 分钟

本文主要记录Java容器相关的内容。
更多详细Java学习记录，请看我的另一篇文章：链接点我

1.容器关系图

如图所示：
Java容器关系图

2.Iterator迭代器

主要用于遍历Collection中的元素。由于Java没有指针，所以迭代器的使用相比C++更复杂一点。

2.1 常用方法

  • import java.util.Iterator;
  • public E next() ：返回迭代的下一个元素。
  • public boolean hasNext() ：如果仍有元素可以迭代，返回true。
  • public void remove()： 删除当前指针所指向的元素，一般和next方法一起用，这时候的作用就是删除next方法返回的元素。

2.2 使用实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class test 
{
	public static void main(String[] args)
	{
		Collection<Integer> t1 = new ArrayList<>();
		t1.add(1);
		t1.add(2);
		t1.add(3);
		t1.add(4);
		t1.add(5);
		//while循环遍历
		Iterator<Integer> iter1 = t1.iterator();
		while(iter1.hasNext())
		{
			int temp = iter1.next();
			System.out.println(temp);
		}
		//for循环遍历
		for(Iterator<Integer> iter2 = t1.iterator();iter2.hasNext();)
		{
			int temp = iter2.next();
			System.out.println(temp);
		}
	}
}

2.3 增强for循环

增强for循环，用来遍历集合和数组。
是JDK1.5之后出现的新特性，底层使用的也是迭代器，但是简化了使用方法。(不用导Iterator包)

格式：

1
2
3
4
for(集合/数组的数据类型 变量名 : 集合名/数组名)
{
	System.out.println(变量名);
}

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Collection;
import java.util.ArrayList;
public class test 
{
	public static void main(String[] args)
	{
		Collection<Integer> t1 = new ArrayList<>();
		t1.add(1);
		t1.add(2);
		t1.add(3);
		t1.add(4);
		t1.add(5);
		//增强for循环
		for(int i : t1)
		{
			System.out.println(i);
		}
	}
}

3.Collection（单列集合）

Collection是所有单列集合的父接口，其中定义了单列集合(List和Set)通用的一些方法，这些方法可以用于操作所有的单列集合。

  • import java.util.Collection;
  • public boolean add(E e) ：把给定的对象添加到当前集合中。
  • public void clear() ：清空集合中的所有元素。
  • public boolean remove(E e) ：把给定的对象在当前集合中删除。
  • public boolean contains(E e) ：判断当前集合中是否包含给定的对象。
  • public boolean isEmpty() ：判断当前集合是否为空。
  • public int size() ：返回集合中元素的个数。
  • public Object[] toarray() ：把集合中的元素，储存到数组中。
  • public Iterator iterator() ： 获取集合所依赖的迭代器对象。

3.1 List（列表）

List接口为有序的集合，并且存在索引，**包含了一些带索引的方法(特有)**。List接口中允许存储重复的元素。

  • import java.util.List;
  • public void add(int index, E element) ：将指定的元素，添加到该集合指定的位置上。
  • public E get(int index) ：返回集合中指定位置的元素。
  • public E remove(int index) ：移除列表中指定的元素，返回的为被移除的元素。
  • public E set(int index, E element) ：用指定的元素替换集合中指定位置的元素，返回值为更新前的元素。

3.1.1 ArrayList

ArrayList储存结构为数组结构，通过List接口实现大小可变的数组。元素增删慢，查找快。
ArrayList的实现是多线程的，也就是实现不是同步的，效率高，但是存在线程安全问题。

  • import java.util.ArrayList;

3.1.2 LinkedList

LinkedList储存结构为链表结构，通过List接口实现双向链表。元素增删快，查找慢。
LinkedList提供了大量首尾操作的特有方法，跟C++的STL队列方法思路都差不多。

  • import java.util.LinkedList;
  • public void addFirst(E e) ：将指定元素添加到列表的开头。
  • public void addLast(E e) ：将指定元素添加到列表的结尾。
  • public E getFirst() ：返回此列表的第一个元素。
  • public E getLast() ：返回此列表的最后一个元素。
  • public E removeFirst() ：移除并返回列表的第一个元素。
  • public E removeLast() ：移除并返回列表的最后一个元素。
  • public E pop() ：从此列表的堆栈处弹出一个元素。此处等效于removeFirst();
  • public void push(E e) ：将元素推入列表的堆栈。此处等效于addFirst();
  • public boolean isEmpty() ：如果列表不包含元素，返回true。

3.1.3 Vector

Vector储存结构为数组结构，通过List接口实现大小可变的数组。元素增删慢，查找快。
Vector的实现是单线程的，即实现是同步的，所以效率比ArrayList要低，但是不存在线程安全问题。

  • import java.util.Vector;

3.2 Set（集合）

Set接口与Collection接口中的方法基本一致，没有对Collection进行功能上的扩充，但是比Collection接口更加严格。
Set接口中元素无序，且都会以某种规则保证存入的元素不出现重复。也不能通过普通的for循环进行遍历。 (参考C++中的set即可)

  • import java.util.Set;

3.2.1 HashSet

底层为一个哈希表(数组加红黑树)，查询的速度非常快。且为一个无序的集合，存储和取出元素的顺序不一定一样。
在进行数据add存储时，首先使用hashCode()方法获取哈希值进行比较，如果无重复则直接填入。如果存在哈希冲突，则使用equals()方法进行判重，如果不存在重复则填入。

  • import java.util.HashSet;
  • 在HashSet存储自定义类型元素时，需重写对象的hashCode方法和equals方法，建立自己的比较方式，从而保证集合中对象唯一。

3.2.2 LinkedHashSet

底层为一个哈希表+链表，多的这条链表用来记录元素的存储顺序，保证元素有序，即存储和取出元素的顺序一样。

  • import java.util.LinkedHashSet;

4.Map（双列集合/图）

Map为双列集合，一个元素里有两个值(key和value)。key不可重复，value可重复。

  • import java.util.Map;
  • public V put(K key, V value) ：把指定的键与指定的值添加到Map集合中。
  • public V remove(Object key) ：把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
  • public V get(Object key) ：根据指定的键，在Map集合中获取对应的值。
  • boolean containsKey(Object key) ：判断集合中是否包含指定的键。
  • public Set<K> keySet() ：获取Map集合中所有的键，存储到Set集合中。
  • public Set<Map.Entry<K,V>> entrySet() ：获取到Map集合中所有的 键值对 对象的集合(Set集合)。

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.util.Set;
import java.util.Map;
import java.util.HashMap;
public class test 
{
	public static void main(String[] args)
	{
		Integer temp;
		Map<String,Integer> map = new HashMap<>();
		//put添加元素 如果key不重复返回值为null;如果key重复,替换value,返回值是老value
		temp = map.put("张三", 18);//temp = null
		temp = map.put("张三", 19);//temp = 18
		System.out.println(temp);
		//remove删除元素 key存在,返回value值;key不存在,返回null
		map.put("李四", 20);
		temp = map.remove("李四");//temp = 20
		temp = map.remove("王五");//temp = null
		System.out.println(temp);
		//get获取元素 key存在,返回value值;key不存在,返回null
		temp = map.get("张三");//temp = 19
		temp = map.get("赵六");//temp = null
		System.out.println(temp);
		//containsKey通过key判断集合中是否包含指定元素 存在返回true
		boolean bool = map.containsKey("张三");//true
		bool = map.containsKey("赵六");//false
		System.out.println(bool);
		
		//keySet 获取一个set,其中储存了map的所有key值
		Set<String> set = map.keySet();
		for(String i : set)//随后就可以根据set使用增强for或者迭代器进行遍历
		{
			temp = map.get(i);
			System.out.println(i+" "+temp);
		}
		
		//entrySet 返回一个set,其中储存了map中的所有Entry对象
		Set<Map.Entry<String,Integer>> set1 = map.entrySet();
		for(Map.Entry<String,Integer> i : set1)//遍历set集合,获取每一个Entry对象
		{
			//通过Entry对象中的方法获取key和value
			String key = i.getKey();
			Integer value = i.getValue();
			System.out.println(key+" "+value);
		}
	}
}

4.1 HashMap

底层为哈希表(数组+链表/红黑树)，查询速度很快。且为一个无序的集合，存储和取出元素的顺序不一定一样。

  • import java.util.HashMap;
  • 在HashMap存储自定义类型元素时，需重写key元素的hashCode方法和equals方法，从而保证key唯一。

4.2 LinkedHashMap

底层为哈希表+链表，多的这条链表用来记录元素的存储顺序，保证元素有序，即存储和取出元素的顺序一样。

  • import java.util.LinkedHashMap;

4.3 Hashtable

底层为哈希表，与HashMap基本一致。其与HashMap的关系，类似Vector与ArrayList的关系。

区别：

  1. HashMap键值可以为null，但是Hashtable的键值都不能为空。
  2. Hashtable为单线程，线程安全但是速度慢。
  • import java.util.Hashtable;

5.Collections集合工具类

  • import java.util.Collections;
  • public static <T> boolean addAll(Collection<T> c, T…elements) ：往集合中添加一些元素。
  • public static void shuffle(List<?> list) ：打乱集合顺序。
  • public static <T> void sort(List<T> list) ：将集合中元素按照默认规则排序。(默认为升序)
  • public static <T> void sort(List<T> list, Comparator<? super T> ) ：将集合中元素按照指定规则排序。

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class test 
{
	public static void main(String[] args)
	{
		ArrayList<Integer> t1 = new ArrayList<>();
		//addAll 添加1，2，3，4，5
		Collections.addAll(t1,1,2,3,4,5);
		//shuffle 打乱顺序 每次执行顺序都不一样
		Collections.shuffle(t1);
		//sort默认排序 默认为升序
		Collections.sort(t1);
		//sort自定义排序 降序
		Collections.sort(t1,new Comparator<Integer>()
		{
			@Override//重写compare方法
			public int compare(Integer o1,Integer o2)/
			{
				//后减前为降序 前减后为升序
				return o2-o1;
			}
		});
		//增强for循环
		for(int i : t1)
		{
			System.out.println(i);//5 4 3 2 1
		}
	}
}