集合知识1,list,vector,set,linkedList,map,LinkedHashMap

Collection集合方法介绍

Collection<String> c = new ArrayList<>();
// boolean add(E e) 添加
boolean b = c.add("hello");
System.out.println(b);
//boolean addAll(Collection<? extends E> c)  添加一个集合
Collection<String> c2 = new ArrayList<String>();
c2.add("李现");
c2.add("蔡旭");
c.addAll(c2);
// boolean contains(Object o)包含
boolean flag = c2.contains("蔡旭");
System.out.println(flag);
		
// boolean containsAll(Collection<?> c)  是否包含集合
flag = c.containsAll(c2);
System.out.println(flag);
		
//boolean isEmpty() 是否为空
boolean empty = c1.isEmpty();
System.out.println(empty);
// boolean remove(Object o)  删除
c.remove("world");
System.out.println(c);
//boolean removeAll(Collection<?> c)  删除集合
c1.removeAll(c2);
System.out.println(c1);
// void clear()  清除全部
c1.clear();
// int size()  集合长度
int size = c.size();
System.out.println(size);
// Object[] toArray()  集合转数组
Object[] array = c.toArray();
for(Object s : array) {
	System.out.println(s);
}
// <T> T[] toArray(T[] a) 集合转成不同类型的数组
String[] arr = c.toArray(new String[c.size()]);
for(String s : arr) {
	System.out.println(s);
}
// Iterator<E> iterator()   迭代器
Iterator<String> it = c.iterator();
while(it.hasNext()) {
	String e = it.next();
	System.out.println(e);
}

List集合的方法介绍

// List集合的方法介绍
List<String> list = new ArrayList<>();
// void add(int index, E element)
// boolean addAll(int index, Collection<? extends E> c)
// E set(int index, E element)  修改
// E remove(int index)  删除
// 注意：调用List集合中remove()方法时，默认使用的是按元素的下标进行删除
// 如果想要删除元素，则需要把基本数据类型手动转换为包装类
// E get(int index) 查询
// int indexOf(Object o) 获取元素的下标
//int lastIndexOf(Object o)  获取元素最后出现位置的下标
// boolean retainAll(Collection<?> c)
// List<E> subList(int fromIndex, int toIndex) 获取子集和
System.out.println(list); //[world, hello, java]
List<String> subList = list.subList(1, list.size()); // [1,2)
System.out.println(subList); //[hello]

Vector集合演示

package com.vector;

import java.util.Enumeration;
import java.util.Vector;

import org.junit.Test;

//Vector集合演示
public class VectorTest {
	@Test
	public void testAdd() {
		//void addElement(E obj)
		Vector<String> v = new Vector<>();
		v.addElement("abc");
		v.addElement("def");
		v.addElement("hig");
		v.addElement(null);
		
		System.out.println(v);
		
		// Enumeration<E> elements()
		Enumeration<String> elements = v.elements();
		while(elements.hasMoreElements()) {
			String element = elements.nextElement();
			System.out.println(element);
		}
		
		// void removeElementAt(int index)
		v.removeElementAt(2);
		System.out.println(v);	
	}
}

Set集合的使用(HashSet)

package com.set;

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

import org.junit.Test;

import com.bean.Person;

// Set集合的使用(HashSet)
public class HashSetTest {
	@Test
	public void test3() {
		Set<Person> set = new HashSet<>();
		set.add(new Person("张飞", 20));
		set.add(new Person("关羽", 21));
		set.add(new Person("刘备", 22));
		set.add(new Person("刘备", 22));
		System.out.println(set);
	}
	@Test
	public void test2() {
		Set<String> set = new HashSet<String>();
		set.add("b");
		set.add("a");
		set.add("c");
		set.add("a");
		System.out.println(set);
	}
	
	@Test
	public void test1() {
		Set<Integer> set = new HashSet<>();
		set.add(2);
		set.add(1);
		set.add(3);
		set.add(2);
		System.out.println(set);
	}
	
	@Test
	public void test0() {
		Integer i = 5000;
		System.out.println(i.hashCode());
		
		String s = "";
		System.out.println(s.length());
		System.out.println(s.hashCode());
		
		System.out.println(new Person("张飞", 20).hashCode());
		System.out.println(new Person("张飞", 20).hashCode());
	}	
}

LinkedList集合的方法介绍

package com.linkedlist;

import java.util.LinkedList;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

// LinkedList集合的方法介绍
public class LinkedListTest {
	LinkedList<String> list;
	@Before // 最初会执行
	public void init() {
		list = new LinkedList<String>();
		list.add("java");
		list.add("spring");
		System.out.println(list);
	}
	
	@After // 最后会执行
	public void after() {
		System.out.println(list);
	}
	
	// 添加
	@Test
	public void testAdd() {
		// void addFirst(E e)
		list.addFirst("first");
		list.addFirst("xxxx");
		System.out.println();
		
		// void addLast(E e)
		list.addLast("last");
		list.addLast("yyy");
		
		System.out.println("---------------");
		
		//boolean offer(E e) 将指定的元素添加到列表的尾部（最后一个元素）。
		list.offer("haha");
		System.out.println("---------");
		//boolean offerFirst(E e) 在列表的前面插入指定的元素。
		list.offerFirst("1111");
		//boolean offerLast(E e) 在列表的结尾插入指定的元素。
		list.offerLast("33333");
		
		System.out.println("---------");
		
		// void push(E e)
		list.push("push");

	}

	// 修改
	
	// 获取
	@Test
	public void testQuery() {
		// E element()
		String e = list.element();
		System.out.println(e);
		
		// E getFirst()
		String first = list.getFirst();
		System.out.println(first);
		
		// E getLast()
		String last = list.getLast();
		System.out.println(last);
		
		System.out.println("-----------");
		
		// E peek() 检索，但不删除，此列表的头（第一个元素）。
		String peek = list.peek();
		System.out.println(peek);
		// E peekFirst() 检索，但不删除该列表的第一个元素，或返回 null如果这个列表是空的。  
		String peekFirst = list.peekFirst();
		System.out.println(peekFirst);
		// E peekLast() 检索，但不删除该列表的最后一个元素，或返回 null如果这个列表是空的。 
		String peekLast = list.peekLast();
		System.out.println(peekLast);
		
		System.out.println("------------");
		
		// E pop()
		String pop = list.pop();
		System.out.println(pop);
	}

	// 删除
	@Test
	public void testDelete() {
		// E poll() 检索并删除此列表的头（第一个元素）。 
		//String poll = list.poll();
		//System.out.println(poll);
		// E pollFirst() 检索并移除此列表的第一个元素，或返回 null如果这个列表是空的。  
//		String pollFirst = list.pollFirst();
//		System.out.println(pollFirst);
//		pollFirst = list.pollFirst();
//		System.out.println(pollFirst);
//		pollFirst = list.pollFirst();
//		System.out.println(pollFirst);
		
		// E pollLast() 检索并移除此列表的最后一个元素，或返回 null如果这个列表是空的。 
		//String pollLast = list.pollLast();
		//System.out.println(pollLast);
		
		// E removeFirst() 移除并返回此列表中的第一个元素。
		String removeFirst = list.removeFirst();
		System.out.println(removeFirst);
		// E removeLast() 移除并返回此列表中的最后一个元素。 
		String removeLast = list.removeLast();
		System.out.println(removeLast);
		
	}
}

Map集合的方法介绍

package com.map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

// Map集合的方法介绍
public class HashMapTest {
	// 添加
	@Test
	public void testAdd() {
		Map<String, String> map = new HashMap<>();
		// V put(K key, V value)
		map.put("aa", "aaaa");
		String v = map.put("bb", "bbbb");
		System.out.println(v);		
		// void putAll(Map<? extends K,? extends V> m)
		Map<String, String> mp2 = new HashMap<String, String>();
		mp2.put("11", "1111");
		mp2.put("22", "2222");
		map.putAll(mp2);
		System.out.println(map);
		map.put("cc", "value");
		System.out.println(map);
	}
	
	// 删除
	@Test
	public void testDelete() {
		Map<String, String> map = new HashMap<>();
		map.put("aa", "aaaa");
		map.put("bb", "bbbb");
		map.put("cc", "cccc");
		System.out.println(map);
		
		// void clear()
		//map.clear();
		//System.out.println(map);
		
		// V remove(Object key)
		map.remove("bb");
		System.out.println(map);
		
		// default boolean remove(Object key, Object value)
		map.remove("aa", "aaaa");
		System.out.println(map);
	}
	
	// 判断
	@Test
	public void testCodition() {
		Map<String, String> map = new HashMap<>();
		map.put("aa", "aaaa");
		map.put("bb", "bbbb");
		map.put("cc", "cccc");
		System.out.println(map);
		
		// boolean containsKey(Object key)
		boolean flag = map.containsKey("aa");
		System.out.println(flag);
		
		// boolean containsValue(Object value)
		flag = map.containsValue("xxx");
		flag = map.containsValue("aaaa");
		System.out.println(flag);
		
		// boolean isEmpty()
		map.clear();
		flag = map.isEmpty();
		System.out.println(flag);
	}
	
	// 获取
	@Test
	public void testGet() {
		Map<String, String> map = new HashMap<>();
		map.put("aa", "aaaa");
		map.put("bb", "bbbb");
		map.put("cc", "cccc");
		System.out.println(map);
		// V get(Object key)
		String val = map.get("aa");
		System.out.println(val);
		
		val = map.get("xx");
		System.out.println(val);
		
		// int size()
		int size = map.size();
		System.out.println(size);
	}
	
	// 替换
	@Test
	public void testReplace() {
		Map<String, String> map = new HashMap<>();
		map.put("aa", "aaaa");
		map.put("bb", "bbbb");
		map.put("cc", "cccc");
		System.out.println(map);
		// V replace(K key, V value)
		map.replace("aa", "11111");
		System.out.println(map);
	}
	
	// 迭代
	@Test
	public void testIterator() {
		Map<String, String> map = new HashMap<>();
		map.put("aa", "aaaa");
		map.put("bb", "bbbb");
		map.put("cc", "cccc");
		
		// Set<K> keySet()
		Set<String> keySet = map.keySet();
		Iterator<String> it = keySet.iterator();
		while(it.hasNext()) {
			String key = it.next();
			String value = map.get(key);
			System.out.println(key + "=" + value);
		}
		System.out.println("------------");
		for(String key : keySet) {
			String value = map.get(key);
			System.out.println(key + "=" + value);
		}
		System.out.println("-------------");
		for(String key : map.keySet()) {
			String value = map.get(key);
			System.out.println(key + "=" + value);
		}
		
		System.out.println("================");
		
		// Collection<V> values()
		Collection<String> values = map.values();
		for (String val : values) {
			System.out.println(val);
		}
		
		System.out.println("================");
		
		// Set<Map.Entry<K,V>> entrySet()
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
		Iterator<Map.Entry<String, String>> it2 = entrySet.iterator();
		while(it2.hasNext()) {
			Map.Entry<String, String> entry = it2.next();
			String key = entry.getKey();
			String val = entry.getValue();
			System.out.println(key + "=" + val);
		}
		
	}
}

LinkedHashMap的使用

package com.map;

import java.util.LinkedHashMap;

import org.junit.Test;

// LinkedHashMap的使用
public class LinkedHashMapTest {
	@Test
	public void test03() {
		LinkedHashMap<Book, Integer> lhm = new LinkedHashMap<>();
		lhm.put(new Book(1, "从入门到放弃"), 33);
		lhm.put(new Book(2, "从入门到精通"), 11);
		lhm.put(new Book(3, "从精通到放弃"), 22);
		System.out.println(lhm);
	}
	
	@Test
	public void test02() {
		LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
		lhm.put("bb", 33);
		lhm.put("aa", 11);
		lhm.put("cc", 22);
		System.out.println(lhm);
	}
	
	@Test
	public void test01() {
		LinkedHashMap<Integer, Integer> lhm = new LinkedHashMap<>();
		lhm.put(3, 33);
		lhm.put(1, 11);
		lhm.put(2, 22);
		System.out.println(lhm);
	}
}