【知晓的丧day拯救计划】java基础学习笔记21 集合

笔记来自：
2019求知讲堂零基础Java入门编程视频教程 https://www.bilibili.com/video/av76235341
尚学堂java300集

手写代码部分未完成

java集合类存放于java.util包中，是一个存放对象的容器
集合只能用于存放对象，如果存放基本数据类型，会被自动转换为对应的引用类型后存入
集合存放的是多个对象的引用，对象本身还是放在堆内存中
集合可以存放不同类型、不限数量的数据

java集合可分为Set、List、Map三大体系
Set：无序不可重复的集合
List：有序，可重复的集合
Map：有映射关系的集合
JDK5之后，增加了泛型，java集合可以记住容器中对象的数据类型。

Collection接口

Collection接口是Set接口和List接口的父接口，他的所有方法都被Set和List继承。

Collection接口中提供了一系列基本抽象方法。
不同的实现类将重写这些方法。

方法	作用
boolean add(Object element)	在集合中添加元素
boolean remove(Object element)	移除集合中指定元素
int size()	返回集合元素个数
void clear()	移除集合中所有元素
boolean isEmpty()	返回集合是否为空
boolean contains(Object element)	返回集合中是否包含指定元素
String toString()	返回集合的字符串序列
Object[] toArray()	将集合元素以Object数组形式返回
boolean containsAll(Collection c)	本集合中是否包含集合c中所有元素
boolean addAll(Collection c)	将集合c中所有元素添加到本集合中
boolean removeall(Collection c)	从本集合中移除集合c中包含的元素
boolean retainAll(Collection c)	取本集合和集合c都包含的元素，移除非交集的元素
Iterator ierator()	获得迭代器，用于遍历集合所有元素

List接口

List代表一个元素有序，且可重复的集合，集合中每个元素都有对应的顺序索引。

• List允许使用重复元素，可以通过索引来访问指定位置的元素
• List默认按元素的添加顺序设置元素索引（索引从0开始）
• List集合里添加了一些根据索引来操作集合元素的方法
• ArrayList底层是用数组实现的，查询效率高，增删效率低，线程不安全，最常用
• 如果想要提高增删效率可以使用LinkedList
• 如果想要线程安全，可以使用Vector

ArrayList

• ArrayList类→实现→List接口→继承→Collection接口

ArrayList类常用方法

通过元素操作集合的方法（实现了Collection接口的抽象方法）：

public class TestArrayList {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		//添加元素
		list.add("b");
		list.add("d");
		list.add("c");
		list.add("b");
		System.out.println(list);         //[b, d, c, b]
		
		//移除元素(只移除第一个匹配的元素)
		list.remove("b");
		System.out.println(list);        //[d, c, b]
		
		//返回集合大小
		System.out.println(list.size()); //3
		
		//返回集合是否为空
		System.out.println(list.isEmpty()); //false
		
		//返回集合中是否包含指定元素
		System.out.println(list.contains("c")); //true
		
		//toString() 直接打印list时，实际上就是调用了list.toString()方法
		System.out.println(list.toString());   //[d, c, b]
		
		//将集合元素以Object数组形式返回
		System.out.println(list.toArray());  //[Ljava.lang.Object;@6a6824be
		for(Object obj:list.toArray()) {
			System.out.println(obj);
		}
		
		//移除集合中所有元素
		list.clear();
		System.out.println(list.size());  // 0
		
		//两个集合的操作
		List<String> a = new ArrayList<String>();
		a.add("d");
		a.add("c");
		a.add("b");
		List<String> c = new ArrayList<String>();
		c.add("a");
		c.add("c");
		
		//集合中是否包含集合c中所有元素
		System.out.println(a.contains(c));  //false
		
		//将集合c中所有元素添加到本集合中
		a.addAll(c);
		System.out.println(a);   //[d, c, b, a, c]
		
		// 从本集合中移除集合c中包含的元素
		a.removeAll(c);
		System.out.println(a);   //[d, b]
		
		//取本集合和集合c都包含的元素，移除非交集的元素
		c.add("b");
		System.out.println(a);  //[d, b]
		System.out.println(c);  //[a, c, b]		
		a.retainAll(c);
		System.out.println(a);  //[b]		
	}
}

根据索引来操作集合元素的方法：

方法	作用
Object get(int index)	按照索引下标获取集合元素
void add(int index,Object ele)	在指定索引下标位置插入元素
boolean addAll(int index,Collection)	在指定索引下标位置插入集合
int indexOf(Object obj)	获取指定元素在集合中第一次出现时的下标
int lastIndexOf(Object obj)	获取指定元素在集合中最后一次出现时的下标
Object remove(int index)	根据指定下标移除元素,返回被移除的元素
Object set(int index,Object ele)	根据指定的索引下标修改元素的值，返回被替换的元素
List subList(int fromIndex.int toIndex)	根据指定索引下标的起始位置和结束位置截取元素，形成一个新的list

import java.util.ArrayList;
import java.util.List;

public class TestArray {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("b");
		list.add("d");
		list.add("c");
		list.add("b");
		System.out.println(list);         //[b, d, c, b]
		
		//按照索引下标获取集合元素 
		//Object get(int index)
		System.out.println(list.get(2));  //c
		
		//在指定索引下标位置插入元素
		//void add(int index,Object ele)
		list.add(2,"a");
		System.out.println(list);         //[b, d, a, c, b]
		System.out.println(list.get(2));  //a
		
		//在指定索引下标位置插入集合
		//boolean addAll(int index,Collection)
		List<String> list2 = new ArrayList<String>();
		list2.add("1");
		list2.add("2");
		list.addAll(3,list2);
		System.out.println(list);         //[b, d, a, 1, 2, c, b]
		
		//获取指定元素在集合中第一次出现时的下标（未找到返回负数）
		//int indexOf(Object obj)
		System.out.println(list.indexOf("b"));  //0
		//获取指定元素在集合中最后一次出现时的下标（未找到返回负数）
		//int lastIndexOf(Object obj)
		System.out.println(list.lastIndexOf("b"));  //6
		
		//根据指定下标移除元素,返回被移除的元素
		//Object remove(int index)
		Object obj1 = list.remove(3);
		System.out.println(obj1);     //1
		System.out.println(list);     //[b, d, a, 2, c, b]
		
		//根据指定的索引下标修改元素的值，返回被替换的元素
		//Object set(int index,Object ele)
		Object obj2 = list.set(5, "f");
		System.out.println(obj2);     //b
		System.out.println(list);     //[b, d, a, 2, c, f]
		
		//根据指定索引下标的起始位置和结束位置截取元素，形成一个新的list
		//截取的时候包含起始位置，但不包含结束位置
		//List subList(int fromIndex.int toIndex)
		List list3 = list.subList(1, 4);  //截取索引下标大于等于1，小于4的元素
		System.out.println(list3);    //[d, a, 2]

	}

}

手写简单的ArrayList，便于理解底层实现

LinkedList

LinkedList底层采用双向链表实现存储，查询效率低，增删效率高，线程不安全。
每一个数据节点都有两个指针，分别指向前一个节点和后一个节点。
所以对比ArrayList增删时需要移动目标位置之后所有元素，LinkedList只需要改变目标节点前后的节点指针的指向，所以增删效率提高。

手写简单的LinkedList，便于理解底层实现

Vector

Vector 底层是用数组实现的，相关方法增加了同步检查，因此是线程安全的，但效率低。

Map

Map用于保存具有映射关系的数据，因此Map集合中保存着两组值，一组保存Key（键），一组用于保存value（值）。Map中的key和value都可以是任何引用类型的数据。
Map 中的key不允许重复（即同一个Map中任意两个key通过equals方法比较，返回值都是false），key和value之间存在单项一对一的关系，即通过指定的key，总能找到唯一确定的value。

HashMap（及Hashtable）

HashMap是对Map接口的经典实现，一般使用的Map都是HashMap。
HashMap→实现→Map接口

HashMap的主要方法

方法	作用
Object put(K key,V value)	添加数据
Object get(Object key)	根据key取value值
int size()	获取map集合的长度
Object remove(Object key)	根据key移除键值对，返回移除的value
boolean containsKey(Object key)	判断map集合中是否包含指定的key
boolean containsValue(Object value)	判断map集合中是否包含指定的value
Set keySet()	获取map集合所有key的集合，返回一个set集合
Collection values()	获取map集合所有的value值的集合，返回一个Collection集合
void clear();	清空集合
boolean isEmpty()	判断Map是否为空

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;


public class TestHashMap {
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String, Integer>();
		
		//添加数据 ，若键重复，则新数据覆盖旧数据
		//put(K key,V value)
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 2);
		map.put("d", 1);
		System.out.println(map);   //{a=1, b=2, c=2, d=1}
		
		//根据key取value值
		//get(Object key) 
		System.out.println(map.get("b"));  //2
		
		
		//根据key移除键值对，返回移除的value
		//remove(Object key)		
		System.out.println(map.remove("c"));  //2
		System.out.println(map);   //{a=1, b=2}
		
		
		//获取map集合的长度
		//size()
		System.out.println(map.size());   //3
		
		//判断map集合中是否包含指定的key
		//containsKey(Object key)
		System.out.println(map.containsKey("b"));  //true
		System.out.println(map.containsKey("c"));  //false
		
		//判断map集合中是否包含指定的value
		//containsValue(Object value)
		System.out.println(map.containsValue(2));  //true
		System.out.println(map.containsValue(3));  //false
		
		//获取map集合所有key的集合，返回一个set集合
		//keySet()
		System.out.println(map.keySet());   //[a, b, d]
		
		//获取map集合所有的value值的集合，返回一个Collection集合
		//values()
		System.out.println(map.values());   //[1, 2, 1]
		
		//遍历map集合,通过map.keySet()
		Set<String> keys = map.keySet();
		for(String key : keys) {
			System.out.println("key:" + key + ",value:" + map.get(key));
		}
		/*
		 key:a,value:1
		 key:b,value:2
		 key:d,value:1		 
		 */
		
		//遍历map集合，通过entrySet()
		//Entry将键值对的对应关系封装成了对象,即每一个entry都是一个键值对对象
		Set<Entry<String, Integer>> entrys = map.entrySet();
		for (Entry<String, Integer> entry : entrys) {
			System.out.println("key:" + entry.getKey() + ",value:" + entry.getValue());
		}
		/*
		 key:a,value:1
		 key:b,value:2
		 key:d,value:1		 
		 */
		
		
		//清空集合、
        //map.clear();
	}

}

HashMap和Hashtable

• HashMap和Hashtable都是Map接口的典型实现
  Hashtable是一个古老的Map实现类，不允许使用null作为key和value，虽然是线程安全的，但也不建议使用。
  HashMap是线程不安全的。
• 与HashSet集合不能保证元素顺序一样，HashMap和Hashtable也不能保证键值对的顺序
• HashMap和Hashtable判断两个key相同的标准是：两个key通过equals方法返回true，且hashcode值也相等
• HashMap和Hashtable判断两个value相同的标准是：两个value通过equals方法返回true。

手写简单的HashMap，便于理解底层实现

HashMap底层实现采用了哈希表，是一种很重要的数据结构。
哈希表的基本结构是“数组+链表”，他集合了数组的快速查询和链表的快速增删。

HashMap的核心数组结构是一个位桶数组 table。这个数组的默认初始长度是16。
数组中每一个元素是一个单向链表，链表的每一个节点由四部分组成：hash值、key、value、下一个节点。

添加数据put()的底层原理
①首先获得key的hashcode（调用对象的hashCode()方法），hashCode是一个整数。
②使用HashMap中的hash()方法，将hashcode转换成一个范围在[0-数组长度)的数字（比如数组长度16，就是0-15）。hash()方法的目的就是使计算出来的hash值可以更均匀的分布在[0-数组长度)区间内，减少hash冲突。
③然后将键值对连接到hash值对应的数组元素链表后。
④JDK8之后的改进，当链表长度大于8时，链表转化为红黑树，提高效率。

常用的hash算法
○ 相除取余法：hash值 = hashcode % 数组长度，这种算法可以使hash值均匀的分布在[，数组长度-1]之间，但除法效率低下。
○ 使用位运算实现取余效果
首先约定数组长度必须是2的整数幂，这样：hash值 = hashcode&（数组长度-1）

取数据get()底层原理
①首先获得key的hashcode，然后通过hash()算法得到哈希值，进而定位到数组的位置
②在对应链表上挨个对比每个对象的key的值，调用equals方法，寻找返回值为true的对象
③返回找到对象中的value值

鉴于HashMap的原理，Java中规定，两个equals方法为true的对象，必须具有相同的hashcode。

扩容问题
HashMap的位桶数组初始大小为16，实际使用时，如果位桶数组整的元素达到（0.75*数组length），就重新调整数组大小为原来的2倍大小。
扩容很耗时，扩容的本质是定义更大的数组，并将就数组的数据挨个拷贝到新数组中。

TreeMap

TreeMap是红黑二叉树的典型实现，可以保证所有的键值对处于有序状态，在存储键值对时，会根据key对键值对进行排序。
TreeMap对key的排序也分为自然排序和定制排序。（一般使用map集合，不会使用过于复杂的对象做key，所以一般用不上定制排序）

自然排序
TreeMap的所有key必须实现Comparable接口，且所有的key必须是同一个类的对象。

例：

import java.util.Map;
import java.util.TreeMap;

public class TestTreeMap {
	public static void main(String[] args) {
		Map<Integer, String> map = new TreeMap<Integer, String>();
		map.put(4, "a");
		map.put(2, "c");
		map.put(3, "d");
		map.put(1, "a");
		 
		System.out.println(map);  
		// {1=a, 2=c, 3=d, 4=a}
		
		Map<String, String> map1 = new TreeMap<String, String>();
		map1.put("b", "a");
		map1.put("c", "c");
		map1.put("a", "d");
		map1.put("ab", "ab");
		map1.put("1", "d");
		map1.put("10", "ab");		
		System.out.println(map1);  
		// {1=d, 10=ab, a=d, ab=ab, b=a, c=c}
	}
}

Set接口

HashSet

HashSet是Set接口的典型实现，大多数时候说的Set集合指的就是HashSet。
HsahSet类→实现→set接口→继承→Collection接口

HashSet的特点：

• 不能保证元素的排列顺序（元素在HashSet中的位置由hashCode决定）
  当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode，然后根据hashCode决定该对象在HashSet中的存储位置。
• 不可重复（指两个元素的hashCode值不相同）
  HashSet集合判断两个元素相等的标准：通过equals()方法比较相等。
• HashSet不是线程安全的
• 集合元素可以使用null

HashSet的常用方法

HashSet的常用方法继承自Collection接口，和ArrayList类通过元素操作集合的方法类似，再次不做赘述。

• set.add() —— 添加元素
• set.remove() —— 移除元素
• set.contains() —— 判断集合中是否存在某元素，返回true/false
• set.isEmpty() —— 判断集合是否为空
• set.clear() —— 清空集合
• set.size() —— 返回集合元素的个数

手写简单的HashSet，便于理解底层实现

HashSet使用Hash算法来存储集合中的元素，实际上就是一个简化的HashMap，在底层代码中，HashSet就是存储在一个HashMap中的，存入的数据都是以key的形式存在，而对应的value都是同一个Object对象常量。因此具有很好地存取和查找性能。

TreeSet

TreeSet类→实现→NavigableSet接口→继承→SortedSet接口→继承→Set接口→继承→Collection接口

和HashMap相同，TreeSet也是TreeMap的简易版本，存入TreeSet的数据实际上作为key存入一个TreeMap，对应的value是一个固定的Object对象。

TreeSet可以确保集合元素处于排序状态。支持两种排序方法：自然排序和定制排序。默认情况下，采取自然排序。

自然排序
TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排列。

compareTo(Object obj)方法：

• this > obj,返回正数1
• this < obj,返回负数-1
• this = obj,返回0，认为这两个对象相等。

TreeSet必须放入相同类型的对象，否则可能会发生类型转换异常，可以使用泛型来进行限制。

定制排序
想要按照类中的某个属性对类对象进行排序，可以让该类实现Comparator接口，并重写compare(Object obj1，Object obj2)方法，实现定制排序。

例如，按照Person类的age属性从小到大排列存放在TreeSet中的Person对象

//导入需要的包
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet {
	public static void main(String[] args) {	
		Person person1 = new Person("张三",30);
		Person person2 = new Person("李四",35);
		Person person3 = new Person("王麻子",49);
		Person person4 = new Person("赵六",21);
		//一个存放Person对象的TreeSet
		Set<Person> set = new TreeSet<Person>(new Person());
		set.add(person1);
		set.add(person2);
		set.add(person3);
		set.add(person4);
		
		//for each循环输出TreeSet中的对象信息
		for (Person p:set) {
			System.out.println(p.name + "  " + p.age);
		}		
	}
}

//Person类，实现Comparator接口
class Person implements Comparator<Person>{
	int age;
	String name;
	//空构造方法
	public Person() {
		
	};
	//两个参数的构造方法
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	//重写接口中的方法，用来比较大小
	@Override
	public int compare(Person o1, Person o2) {
		if (o1.age > o2.age) {
			return 1;
		}else if(o1.age < o2.age){
			return -1;
		}else {
			return 0;
		}		
	}	
}

集合遍历

使用Iterator接口遍历集合元素

Iterator接口主要用于遍历集合中的元素，也被称为迭代器。其隐藏了各种集合实现类的底层细节，向应用程序提供了遍历集合元素的统一接口。Iterator仅用于遍历集合，本身不提供承装对象的能力，如果要创建Iterator对象，则必须有一个被迭代的集合。

boolean hasNext()
Object next()
remove()-遍历的同时删除元素

public class TestSet {
	public static void main(String[] args) {
		Set set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		set.add("d");
				
		//使用迭代器遍历集合
		Iterator it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

使用for each循环遍历集合元素

public class TestSet {
	public static void main(String[] args) {
		Set set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		set.add("d");
		
		//for each迭代集合
		for(Object obj:set) {//把set的每一个值取出来赋值给obj，直到循环set中的所有值
			System.out.println(obj);
		}
	}
}

Collections工具类

collections是一个操作Set、List和Map等集合的工具类，其中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变，对集合对象实现同步控制等方法。

排序操作

• reverse(List)：翻转list中的元素顺序
• shuffle(List)：对List集合元素进行随机排序
• sort(List)：List集合的元素按升序排序
• sort(List,Comparator)：根据指定的Comparator产生的顺序对List集合的元素进行排序
• swap(List,int,int)：将指定List集合中的第i处元素和第j处元素进行交换

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class TestCollections {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("b");
		list.add("cd");
		list.add("ca");
		list.add("a");
		list.add("1");
		
		System.out.println(list);   //[b, cd, ca, a, 1]
		
		//翻转list中的元素顺序
		//void reverse(List)
		Collections.reverse(list);
		System.out.println(list);   //[1, a, ca, cd, b]
		
		//将指定List集合中的第i处元素和第j处元素进行交换
		//swap(List list,int i,int j)
		Collections.swap(list, 1, 3);
		System.out.println(list);  //[1, cd, ca, a, b]
		
		//对List集合元素进行随机排序
		//void shuffle(List)
		Collections.shuffle(list);
		System.out.println(list);  //[ca, b, a, cd, 1]
		
		//List集合的元素按升序排序
		//void sort(List)
		Collections.sort(list);
		System.out.println(list);  //[1, a, b, ca, cd]
		
		//————————————————————————————————————————————
		//根据指定的Comparator产生的顺序对List集合的元素进行排序
		Student s1 = new Student(14,"Lily");
		Student s2 = new Student(12,"Andy");
		Student s3 = new Student(13,"Sara");
		Student s4 = new Student(18,"李华");
		
		List<Student> stus = new ArrayList<Student>();
		stus.add(s1);
		stus.add(s2);
		stus.add(s3);
		stus.add(s4);
		
		for(Student stu:stus) {
			System.out.println("姓名：" + stu.name + ",年龄" + stu.age);
		}
		/*
		 * 姓名：Lily,年龄14
		 * 姓名：Andy,年龄12
		 * 姓名：Sara,年龄13
		 * 姓名：李华,年龄18
		 */
		
		//根据指定的Comparator产生的顺序对List集合的元素进行排序
		//void sort(List,Comparator)
		Collections.sort(stus, new Student());
		for(Student stu:stus) {
			System.out.println("姓名：" + stu.name + ",年龄" + stu.age);
		}
		/*
		 * 姓名：Andy,年龄12
		 * 姓名：Sara,年龄13
		 * 姓名：Lily,年龄14
		 * 姓名：李华,年龄18
		 */
	}
	

}

class Student implements Comparator<Student>{
	int age;
	String name;
	
	public Student() {		
	}
	
	public Student(int age,String name) {
		this.age = age;
		this.name = name;
	}
	
	//重写方法，实现按年龄升序排序
	@Override
	public int compare(Student o1, Student o2) {
		if(o1.age > o2.age) {
			return 1;
		}else if(o1.age < o2.age) {
			return -1;
		}else {
			return 0;
		}		
	}	
}

查找、替换、排序

• Object max(Collection)：
  返回集合中的最大元素
• Object max(Collection，Comparator)：
  根据Comparator指定的顺序，返回集合中的最大元素
• Object min(Collection)：
  返回集合中的最小元素
• Object min(Collection，Comparator)：
  根据Comparator指定的顺序，返回集合中的最小元素
• int frequence(Collection，Object)：
  返回集合中指定元素出现的次数
• boolean replaceAll(List list，Object oldVal，Object newVal)：
  使用新值替换list对象的所有旧值
• int binarySearch(List,Object)
  二分法查找指定集合中是否存在指定元素，存在返回索引，不存在返回负数
• void fill(List, Object)
  用一个特定对象Object填充整个集合

//接上面的代码
//List集合的元素按升序排序
Collections.sort(list);
System.out.println(list);  //[1, a, b, ca, cd]

//返回集合中的最大元素
//Object max(Collection)
System.out.println(Collections.max(list)); // cd

//返回集合中的最小元素
//Object min(Collection)
System.out.println(Collections.min(list)); //1

//返回集合中指定元素出现的次数
//int frequence(Collection,Object)
list.add("a");
System.out.println(list); //[1, a, b, ca, cd, a]
System.out.println(Collections.frequency(list, "a"));  // 2

//使用新值替换list对象的所有旧值
//boolean replaceAll(List list,Object oldVal,Object newVal)
Collections.replaceAll(list, "a", "x") ;
System.out.println(list);  //[1, x, b, ca, cd, x]

//二分法查找指定集合中是否存在指定元素，存在返回索引，不存在返回负数
//int binarySearch(List,Object)
System.out.println(Collections.binarySearch(list, "ca")); //3
		
//用一个特定对象填充整个集合
//void fill(List, Object)
Collections.fill(list, "fill");
System.out.println(list);  //[fill, fill, fill, fill, fill, fill]


//根据Comparator指定的顺序，返回集合中的最大元素
//Object max(Collection，Comparator)
Student maxstu = Collections.max(stus, new Student());
//根据Comparator指定的顺序，返回集合中的最小元素
//Object min(Collection，Comparator)
Student minstu = Collections.min(stus, new Student());
System.out.println("姓名：" + maxstu.name + ",年龄" + maxstu.age);
System.out.println("姓名：" + minstu.name + ",年龄" + minstu.age);
/*
* 姓名：李华,年龄18
* 姓名：Andy,年龄12
*/

同步控制
Collections类中提供了多个synchronizeXxx()方法，该方法可将指定集合包装成线程同步的集合，从而解决多线程并发访问时的线程安全问题。

使用容器存储表格数据

id	姓名	年龄	出生日期
2001	张三	26	1994-8-1
2002	李四	30	1990-5-20
2003	王麻子	36	1984-1-13

map和list结合存储表格数据

每一行数据是一个Map
整个表格是一个List

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class TestTable {
	public static void main(String[] args) {
		Map<String,Object> row1 = new HashMap<String, Object>();
		row1.put("id", 2001);
		row1.put("name", "张三");
		row1.put("age", 26);
		row1.put("birth", "1994-8-1");
		Map<String,Object> row2 = new HashMap<String, Object>();
		row2.put("id", 2002);
		row2.put("name", "李四");
		row2.put("age", 30);
		row2.put("birth", "1990-5-20");
		Map<String,Object> row3 = new HashMap<String, Object>();
		row3.put("id", 2003);
		row3.put("name", "王麻子");
		row3.put("age", 36);
		row3.put("birth", "1984-1-13");
		
		List<Map<String,Object>> table = new ArrayList<Map<String,Object>>();
		table.add(row1);
		table.add(row2);
		table.add(row3);
		
		for(Map<String, Object> row :table) {
			Set<String> keySet = row.keySet();
			for(String key:keySet) {
				System.out.print(key + ":" + row.get(key)+" ");
			}
			System.out.println();
		}		
	}
}

Javabean和list结合存储表格数据

每一行数据是一个Javabean
整个表格是一个List

import java.util.ArrayList;
import java.util.List;

public class TestTable2 {
	public static void main(String[] args) {
		Person person1 = new Person(2001, "张三", 26, "1994-8-1");
		Person person2 = new Person(2002, "李四", 30, "1990-5-20");
		Person person3 = new Person(2002, "王麻子", 36, "1984-1-13");
				
		List<Person> list = new ArrayList<Person>();
		list.add(person1);
		list.add(person2);
		list.add(person3);
		
		for(Person p : list) {
			System.out.println(p.toString());
		}
	}
}

class Person {
	private int id;
	private String name;
	private int age;
	private String birth;
	
	public Person() {
	}	
	public Person(int id, String name, int age, String birth) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.birth = birth;
	}
	
	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;
	}
	public String getBirth() {
		return birth;
	}
	public void setBirth(String birth) {
		this.birth = birth;
	}
	
	@Override
	public String toString() {
		return "id:"+getId() + "\t" + "name:"+getName() + "\t" + "age:"+getAge() + "\t" + "birth:"+getBirth();
	}
}