06_Java容器

1、容器架构和数组

1.1 数组的优缺点

• 优点：简单的线性序列，可以快速访问数据，效率高。
• 缺点：不够灵活，容量实现定义好，不能随着需求的变化而变化。

1.2 容器（集合）架构

2、泛型

泛型的本质是：数据类型的参数化。我们可以把它理解为数据类型的一个占位符（形式参数），即告诉编译器，在调用泛型时必须传入实际类型。

泛型声明：

<T,E,V>

public class TestGeneric {
	public static void main(String[] args) {
		MyCollection<String> mc = new MyCollection<>();
		mc.set("lisi", 0);
		mc.set("zhangsan", 1);
		Object object = mc.get(0);
		System.out.println(object);
	}
}

class MyCollection<E> {
	Object[] objs = new Object[5];
	
	public void set(E e,int index ) {
		objs[index] = e;
	}
	public E get(int index) {
		return (E) objs[index];
	}
}

3、Collection接口

Collection表示一组对象，它是集中、收集的意思。他有两个子接口：List和Set，因此List和Set的实现类中都实现了Collection中的方法。

Collection接口中定义的方法：

public class TestCollection {
	public static void main(String[] args) {
		Collection<String> collection = new ArrayList<>();
		
		//添加元素
		collection.add("张三");
		collection.add("李四");
		collection.add("王五");
		
		//查看元素数量
		System.out.println(collection.size());  //3
		
		//判断容器是否为空
		System.out.println(collection.isEmpty());  //false
		
		//判断容器是否包含某个元素
		System.out.println(collection.contains("lisi"));  //false
		
		//转化成Object数组
		System.out.println(collection.toArray());
		
		//从容器中移除元素
		collection.remove("李四");
		System.out.println(collection);
		
		//移除容器中的所有元素
		collection.removeAll(collection);
		System.out.println(collection.size());
	}
}

public class TestCollection2 {
	public static void main(String[] args) {
		Collection<String> c1 = new ArrayList<>();
		c1.add("aa");
		c1.add("bb");
		c1.add("cc");
		
		Collection<String> c2 = new ArrayList<>();
		c2.add("aa");
		c2.add("dd");
		c2.add("ee");
		
		/**
		 * 测试时各个方法相互独立
		 */
		
		//将c2容器中所有的元素添加到c1中
		c1.addAll(c2);  //[aa, bb, cc, aa, dd, ee]
		
		//移除所有c1中和c2相同的元素
		c1.removeAll(c2);  //[bb, cc]
		
		//计算两个容器的交集
		c1.retainAll(c2);  //[aa]
		
		//测试容器c1中是否包含容器c2的全部元素
		c1.containsAll(c2);  //false
	}
}

4、List接口

List是有序，可重复的容器。

• 有序：List中每个元素都有索引标记。
• 可重复：List中允许加入重复的元素。确切地讲，List允许满足e1.equals(e2)的元素重复加入容器。

4.1 List常用的实现类

• ArrayList：底层实现：数组。特点：查询快，增删效率低，线程不安全。
• LinkedList：底层实现：双向链表。特点：查询慢，增删效率高，线程不安全。
• Vector：底层实现：数组，线程安全。
  

如何选择List容器的实现类：

• 需要线程安全，使用Vector
• 不存在线程安全问题时，并且查找较多使用ArrayList（最常用）
• 不存在线程安全问题时，并且增删较多使用LinkdeList

public class TestList {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("AA");
		list.add("BB");
		list.add("CC");
		list.add("DD");
		list.add("CC");
		
		/**
		 * 测试与索引相关的内容
		 */
		
		//在指定位置添加元素
		list.add(1, "BMG");
		
		//移除指定位置的元素
		list.remove(2);
		
		//修改指定位置的元素内容
		list.set(3, "YMMD");
		
		//获取指定位置的元素内容
		System.out.println(list.get(2));
		
		System.out.println(list);  //[AA, BMG, CC, YMMD, CC]
		
		//返回指定元素第一次出现的位置，否则返回-1
		System.out.println(list.indexOf("CC"));  //2
		
		//返回指定元素最后一次出现的位置，否则返回-1
		System.out.println(list.lastIndexOf("CC"));  //4
	}
}

4.2 手写一个ArrayList

public class MyArrayList04<E> {
	private Object[] elementData;
	private int size;
	
	private static final int DEFALT_CAPACITY = 10;
	
	public MyArrayList04() {
		elementData = new Object[DEFALT_CAPACITY];
	}
	
	//判断容器容量是否合法
	public MyArrayList04(int capacity) {
		if (capacity < 0) {
			throw new RuntimeException("容器的容量不能为负数");
		} else if(capacity == 0) {
			elementData = new Object[DEFALT_CAPACITY];
		} else {
			elementData = new Object[capacity];
		}
	}
	
	//add方法
	public void add(E element) {
		//什么时候扩容
		if (size == elementData.length) {
			//怎么扩容
			Object[] newArray = new Object[elementData.length + (elementData.length>>1)];
			System.arraycopy(elementData, 0, newArray, 0, elementData.length);
			elementData = newArray;
		}
		elementData[size++] = element;
	}
	
	//get方法
	public E get(int index) {
		checkRange(index);
		return (E) elementData[index];
	} 
	
	//set方法
	public void set(int index,E element) {
		checkRange(index);
		elementData[index] = element;
	}
	
	//判断索引是否合法
	public void checkRange(int index) {
		if (index < 0 || index > size-1) {
			throw new RuntimeException("索引不合法--》" + index);
		}
	}
	
	//移除元素
	public void remove(int index) {  //根据索移除元素
		int removeNumber = elementData.length-index-1;
		if (removeNumber > 0) {
			System.arraycopy(elementData, index+1, elementData, index, removeNumber);
		} 
		elementData[--size] = null;
	}
	public void remove(E element) {  //根据对象移除元素
		for (int i = 0; i < size; i++) {
			if(element.equals(get(i))) {
				remove(i);
			}
		}
	}
	
	//重写toString方法
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for(int i=0;i<size;i++) {
			sb.append(elementData[i] + ",");
		}
		sb.setCharAt(sb.length()-1, ']');
		return sb.toString();
	}
	
	//测试
	public static void main(String[] args) {
		MyArrayList04<String> ma = new MyArrayList04<>();
		for (int i = 0; i < 20; i++) {
			ma.add("aa" + i);
		}
		System.out.println(ma.get(10));
		ma.set(10, "zhongguo");
		ma.remove(1);
		ma.remove("aa15");
		System.out.println(ma);
	}
}

5、Map接口

Map是用来存储“键（key）- 值（value）对”的。Map存储的“键值对”通过键来标识，所以“键对象”不能重复，否则数据会被覆盖。

5.1 Map常用的实现类

• HashMap：底层实现：哈希表。
• TreeMap：底层实现：红黑树。
• HashTable：线程安全的。
• Properties：继承自HashTable。
  

5.2 Map接口常用的方法

public class TestMap {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		
		//存放键值对
		map.put(1, "one");
		map.put(2, "two");
		map.put(3, "three");
		
		Map<Integer, String> map1 = new HashMap<>();
		map1.put(10, "ten");
		map1.put(6, "six");
		map.put(5, "five");
		
		//将map1中所有的键值对存放到map中
		map.putAll(map1);
		System.out.println(map);
		//通过键对象查找到值对象
		System.out.println(map.get(2));
		
		//移除键对象对应的值对象
		map.remove(3);
		
		//判断容器是否为空
		System.out.println(map.isEmpty());
		
		//容器中是否包含对应的键或值
		System.out.println(map.containsKey(1));
		System.out.println(map.containsValue("four"));
		
		//获取容器的容量
		System.out.println(map.size());
		
		//清空map对象所有键值对
		map.clear();
		System.out.println(map);
	}
}

public class TestMap02 {
	public static void main(String[] args) {
		
		Employee emp1 = new Employee(1001, "张三", 25);
		Employee emp2 = new Employee(1002, "李四", 35);
		Employee emp3 = new Employee(1003, "王五", 45);
		
		Map<Integer, Employee> map = new HashMap<>();
		map.put(1001, emp1);
		map.put(1002, emp2);
		map.put(1003, emp3);
		
		System.out.println(map);
		System.out.println(map.get(1001));
		System.out.println(emp1.getAge());
	}
}

class Employee {
	int id;
	String name;
	int age;
	//构造方法
	public Employee(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
}

5.3 HashMap的存储过程

5.4 TreeMap的使用

• HashMap和TreeMap都实现了接口Map，用法对于调用者没有什么区别。HashMap效率高于TreeMap；在需要排序时，选用TreeMap。
• 使用Comparable接口实现自定义排序。

public class TestTreeMap {
	public static void main(String[] args) {
		Map<Integer, String> treemap = new TreeMap<>();
		treemap.put(1001, "张三");
		treemap.put(1003, "李四");
		treemap.put(1002, "王五");
		
		//按照key递增排序
		for(Integer key:treemap.keySet()) {
			System.out.println(key + "---" + treemap.get(key));
		}
		
		Map<Emp, String> treemap1 = new TreeMap<>();
		treemap1.put(new Emp(1001, "张三", 5000), "张三.......");
		treemap1.put(new Emp(1007, "李四", 7500), "李四.......");
		treemap1.put(new Emp(1003, "王五", 7500), "王五.......");
		treemap1.put(new Emp(1005, "赵柳", 16500), "赵柳.......");
		//自定义排序
		for(Emp key:treemap1.keySet()) {
			System.out.println(key + "------" + treemap1.get(key));
		}
	}
}

class Emp implements Comparable<Emp> {
	int id;
	String name;
	double salay;
	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 double getSalay() {
		return salay;
	}
	public void setSalay(double salay) {
		this.salay = salay;
	}
	@Override
	public String toString() {
		return "Emp [id=" + id + ", name=" + name + ", salay=" + salay + "]";
	}
	public Emp(int id, String name, double salay) {
		super();
		this.id = id;
		this.name = name;
		this.salay = salay;
	}
	
	//自定义排序(先使用salay排序，salay相同使用id排序)
	@Override
	public int compareTo(Emp o) {
		if(this.salay > o.salay) {
			return 1;
		} else if(this.salay < o.salay) {
			return -1;
		} else {
			if(this.id > o.id) {
				return 1;
			} else if(this.id < o.id) {
				return -1;
			} else {
				return 0;
			}
		}
	}
}

6、Set接口

Set是无序，不可重复的容器。

• 无序：Set中的元素没有索引，我们只能通过遍历查找。
• 可重复：Set中不允许加入重复的元素。确切地讲，Set不允许满足e1.equals(e2)的元素重复加入容器，甚至Set中只能存放一个null元素，不能多个。

6.1 Set常用的实现类

• HashSet：底层实现：哈希表。线程不安全。
• TreeSet：底层实现：红黑树。线程不安全。
  

6.2 Set的常用方法

6.3 TreeSet的使用

public class TestTreeSet {
	public static void main(String[] args) {
		Set<Emp1> treemap1 = new TreeSet<>();
		treemap1.add(new Emp1(1001, "张三", 5000));
		treemap1.add(new Emp1(1007, "李四", 7500));
		treemap1.add(new Emp1(1003, "王五", 7500));
		treemap1.add(new Emp1(1005, "赵柳", 16500));
		//自定义排序
		for(Emp1 m:treemap1) {
			System.out.println(m);
		}
	}
}

class Emp1 implements Comparable<Emp1> {
	int id;
	String name;
	double salay;
	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 double getSalay() {
		return salay;
	}
	public void setSalay(double salay) {
		this.salay = salay;
	}
	@Override
	public String toString() {
		return "Emp [id=" + id + ", name=" + name + ", salay=" + salay + "]";
	}
	public Emp1(int id, String name, double salay) {
		super();
		this.id = id;
		this.name = name;
		this.salay = salay;
	}
	
	//自定义排序(先使用salay排序，salay相同使用id排序)
	@Override
	public int compareTo(Emp1 o) {
		if(this.salay > o.salay) {
			return 1;
		} else if(this.salay < o.salay) {
			return -1;
		} else {
			if(this.id > o.id) {
				return 1;
			} else if(this.id < o.id) {
				return -1;
			} else {
				return 0;
			}
		}
	}
}

7、迭代器

迭代器提供了统一的遍历容器的方式。

7.1 使用Iterator遍历容器

public class TestIterator {
	public static void main(String[] args) {
		testIteratorList();
		testIteratorSet();
		testIteratorMap();
		testIteratorMap1();
	}
	
	//使用Iterator遍历List
	public static void testIteratorList() {
		List<String> list = new ArrayList<>();
		list.add("aa");
		list.add("bb");
		list.add("cc");
		for(Iterator<String> iterator = list.iterator();iterator.hasNext();) {
			String temp = iterator.next();
			System.out.println(temp);
		}
	}
	
	//使用Iterator遍历Set
	public static void testIteratorSet() {
		Set<String> set = new HashSet<>();
		set.add("dd");
		set.add("ee");
		set.add("ff");
		for(Iterator<String> iterator = set.iterator();iterator.hasNext();) {
			String temp = iterator.next();
			System.out.println(temp);
		}
	}
	
	//使用Iterator遍历Map（第一种方式:entrySet）
	public static void testIteratorMap() {
		Map<Integer, String> map = new HashMap<>();
		map.put(1001, "张三");
		map.put(1002, "李四");
		map.put(1003, "王五");
		Set<Entry<Integer, String>> entrySet = map.entrySet();
		for(Iterator<Entry<Integer, String>> iterator = entrySet.iterator();iterator.hasNext();) {
			Entry<Integer, String> temp = iterator.next();
			System.out.println(temp.getKey() + "---" + temp.getValue());
		}
	}
	
	//使用Iterator遍历Map（第一种方式:keySet）
		public static void testIteratorMap1() {
			Map<Integer, String> map = new HashMap<>();
			map.put(1001, "张三");
			map.put(1002, "李四");
			map.put(1003, "王五");
			Set<Integer> keySet = map.keySet();
			for(Iterator<Integer> iterator = keySet.iterator();iterator.hasNext();) {
				Integer temp = iterator.next();
				System.out.println(temp + "---" + map.get(temp));
			}
		}
}

7.2 遍历容器（集合）的方法汇总（以List为例）

List—普通for循环

for（int i=0;i<size();i++）{
	String temp = (String)list.get(i);
	System.out.println(temp);
}

List—增强for循环

for（String temp:list）{
	System.out.println(temp);
}

List—迭代器1

for(Iterator<String> iterator = list.iterator();iterator.hasNext();) {
	String temp = iterator.next();
	System.out.println(temp);
}

List—迭代器1

Iterator<String> iterator = list.iterator();
while(iterator.hashNext()){
	Object obj = iterator.next();
	iterator.remove();  //如果在遍历时，需要删除集合中的元素，建议使用这种方式
	System.out.println(obj );
}

Map—使用entrySet

Set<Entry<Integer, String>> entrySet = map.entrySet();
for(Iterator<Entry<Integer, String>> iterator = entrySet.iterator();iterator.hasNext();) {
	Entry<Integer, String> temp = iterator.next();
	System.out.println(temp.getKey() + "---" + temp.getValue());
}

Map—使用keySet

Set<Integer> keySet = map.keySet();
for(Iterator<Integer> iterator = keySet.iterator();iterator.hasNext();) {
	Integer temp = iterator.next();
	System.out.println(temp + "---" + map.get(temp));
}

8、Collections工具类

java.util.Collections工具类提供了对Set、List、Map进行排序、填充、查找元素的辅助方法。

public class TestCollections {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		for(int i=0;i<10;i++) {
			list.add("xxx : " + i);
		}
		System.out.println(list);
		
		//随机排列
		Collections.shuffle(list);
		System.out.println(list);
		
		//逆序排列
		Collections.reverse(list);
		System.out.println(list);
		
		//递增排序
		Collections.sort(list);
		System.out.println(list);
		
		//折半查找
		System.out.println( Collections.binarySearch(list, "xxx : 7"));
	}
}

9、使用集合存储数据信息

学号	姓名	性别	年龄
1001	张三	男	25
1002	李四	女	36
1003	王五	男	17

第一种方式：（javabean）

public class TestJavaBean {
	public static void main(String[] args) {
		Student student1 = new Student(1001, "张三", "男", 25);
		Student student2 = new Student(1002, "李四", "女", 36);
		Student student3 = new Student(1003, "王五", "男", 17);
		
		List<Student> list = new ArrayList<>();
		list.add(student1);
		list.add(student2);
		list.add(student3);
		
		for(Student s:list) {
			System.out.println(s);
		}
	}

}

class Student {
	private int id;
	private String nane;
	private String sex;
	private int age;
	
	public Student() {
	}
	public Student(int id, String nane, String sex, int age) {
		super();
		this.id = id;
		this.nane = nane;
		this.sex = sex;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", nane=" + nane + ", sex=" + sex + ", age=" + age + "]";
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getNane() {
		return nane;
	}
	public void setNane(String nane) {
		this.nane = nane;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

第二种方式：（集合）

public class TestListMapSet {
	public static void main(String[] args) {
		Map<String, Object> map1 = new HashMap<>();
		map1.put("学号", 1001);
		map1.put("姓名", "张三");
		map1.put("性别", "男");
		map1.put("年龄", 25);
		
		Map<String, Object> map2 = new HashMap<>();
		map2.put("学号", 1002);
		map2.put("姓名", "李四");
		map2.put("性别", "女");
		map2.put("年龄", 36);
		
		Map<String, Object> map3 = new HashMap<>();
		map3.put("学号", 1003);
		map3.put("姓名", "王五");
		map3.put("性别", "男");
		map3.put("年龄", 17);
		
		List<Map<String, Object>> list = new ArrayList<>();
		list.add(map1);
		list.add(map2);
		list.add(map3);
		
		for(Map<String, Object> row:list) {
			System.out.println(row);
			
			Set<String> keySet = row.keySet();
			for(String key:keySet) {
				System.out.print(key + "--" + row.get(key) + "\t");
			}
			System.out.println();
		}
	}
}