一、 什么是集合：
在Java中提供了一些可以保存同一数据类型的数据集称为集合，就是规定了一些集合的规范（接口、抽象类、实现类）及方法，
方便我们程序在保存数据时进行增、删、改、查操作，编程更加高效。
二、 List集合：
List集合特性：List集合（ArrayList、LinkedList）是可重复的、有序的（是原始顺序）
1、ArrayList实现类：底层采用数组实现，查询可以通过下标快速点位，查询速度快，针对添、删、改速度慢
2、LinkedList实现类：底层采用双向链表实现，添加、删除时通过修改操作元素的前后索引值即可，效率高；
针对查询就需要从第一个查询到最后一个，查询效率低
package com.oop.ch07.test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.junit.Test;
import com.oop.ch07.Dept;
/**
*练习List集合的使用：ArrayList、LinkedList
*
*/
public class ListTest {
//测试arraylist的基本用法
@Test
public void testArrayList1() {
List arrayList1 = new ArrayList();
//将元素值追加到集合中
arrayList1.add("aa");
arrayList1.add("gg");
arrayList1.add("bb");
arrayList1.add("cc");
//将元素值插入到index（从0开始）指定的位置，其他的元素往后挪
arrayList1.add(1, "mm");
for (Object a : arrayList1) {
System.out.println(a);
}
System.out.println("----------------------");
Integer element0 = (Integer) arrayList1.get(0);
System.out.println(element0);
}
//泛型
@Test
public void testArrayList2() {
//在创建实现类ArrayList的对象时，Java7.0及以上的版本泛型会参考左边
List<String> arrayList1 = new ArrayList<String>();
//将元素值追加到集合中
arrayList1.add("aa");
arrayList1.add("gg");
arrayList1.add("bb");
arrayList1.add("cc");
//将元素值插入到index（从0开始）指定的位置，其他的元素往后挪
arrayList1.add(1, "mm");
for (Object a : arrayList1) {
System.out.println(a);
}
System.out.println("----------------------");
//添加泛型以后可以将运行时异常提前为检查性异常，更容易被发现此异常，并及时处理
//Integer element0 = (Integer) arrayList1.get(0);
String element0 = arrayList1.get(0);
System.out.println(element0);
}
//基本数据类型和包装数据类型
@Test
public void arrayList3() {
List<Float> studentNos = new ArrayList<Float>();
//自动装箱：能将基本数据类型（float）自动转换为包装数据类型（Float）
studentNos.add(1.0F);
studentNos.add(2.0F);
//自动拆箱：能将包装数据类型自动转换为基本数据类型
float no1 = studentNos.get(1);
System.out.println(no1);
}
/**
* 练习List（ArrayList、LinkedList）集合中提供的常用方法
*/
@Test
public void arrayList4() {
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("aaa");
//在集合中从前向后查找指定的元素值对应的索引位置
int index1 = list.indexOf("aaa"); //从前往后
System.out.println(index1);
//在集合中从后向前查找指定的元素值对应的索引位置
int index2 = list.lastIndexOf("aaa"); //从后往前
System.out.println(index2);
//判断集合中是否包含指定的元素,包含为true
//list.contains("ccc");
System.out.println(list.contains("ccc"));
//通过索引删除指定位置的元素，返回删除的元素值
list.remove(3);
System.out.println(list.remove(3));
//通过元素删除对应的元素，返回是否删除成功
//list.remove("bbb");
System.out.println(list.remove("bbb"));
//返回集合元素个数
System.out.println(list.size());
//Iterator迭代器，循环遍历元素
/*
* 返回该集合的所有元素，并把他们放置到一个iterator迭代器中，
* it.hasNext():返回迭代器中是否还有下一个元素
* it.net():返回正在迭代的元素值，将指针向下移动一个单位
*/
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
/**
* 练习LinkedList集合中提供的常用方法
*/
@Test
public void testLinledList() {
List<String> list = new LinkedList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("aaa");
for (String element : list) {
System.out.println(element);
}
//在集合中从前向后查找指定的元素值对应的索引位置
int index1 = list.indexOf("aaa"); //从前往后
System.out.println(index1);
//在集合中从后向前查找指定的元素值对应的索引位置
int index2 = list.lastIndexOf("aaa"); //从后往前
System.out.println(index2);
//判断集合中是否包含指定的元素,包含为true
//list.contains("ccc");
System.out.println(list.contains("ccc"));
//通过索引删除指定位置的元素，返回删除的元素值
list.remove(3);
System.out.println(list.remove(3));
//通过元素删除对应的元素，返回是否删除成功
//list.remove("bbb");
System.out.println(list.remove("bbb"));
//返回集合元素个数
System.out.println(list.size());
//Iterator迭代器，循环遍历元素
/*
* 返回该集合的所有元素，并把他们放置到一个iterator迭代器中，
* it.hasNext():返回迭代器中是否还有下一个元素
* it.net():返回正在迭代的元素值，将指针向下移动一个单位
*/
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
/*
* 在List中放实体,实体类代码放在最后
*/
@Test
public void testArrayListEntity() {
List<Dept> deptList = new ArrayList<Dept>();
deptList.add(new Dept("人事部","北京"));
deptList.add(new Dept("财务部","上海"));
deptList.add(new Dept("公关部","昆明"));
deptList.add(new Dept("综合部","山东"));
for (Dept dept : deptList) {
System.out.println(dept);
}
}
}
三、 Set集合：
1、HashSet实现类：不可重复的、是无序的，Hash算法就是随机算法。
package com.oop.ch07.test;
import java.util.*;
/*
* 练习HashSet集合的使用
*/
public class HashSetTest {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
System.out.println("set集合是否为空：" + set.isEmpty());
set.add("aaa");
set.add("bbb");
set.add("ccc");
set.add("ddd");
set.add("eee");
set.add("aaa");
for (String element : set) {
System.out.println(element);
}
System.out.println("---------");
//只能通过值删除
set.remove("eee");
for (String element : set) {
System.out.println(element);
}
//集合的长度
System.out.println("Set集合的长度：" + set.size());
//Iterator迭代器，遍历set
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
2、TreeSet实现类：不可重复的、是有序的（自然顺序，a-z、0-9）
package com.oop.ch07.test;
import java.util.*;
/*
* 练习TreeSet集合的使用：自然顺序
TreeSet集合的大多数方法都和HashSet一样的
*/
public class TreeSetTest {
public static void main(String[] args) {
Set<String> set = new TreeSet<String>();
set.add("aaa");
set.add("ccc");
set.add("bbb");
set.add("ddd");
set.add("eee");
set.add("aaa");
for (String element : set) {
System.out.println(element);
}
}
}
四、 Map集合：
Map集合采用“键值对”的entry结构，每一个元素由key（键）和value(值)构成，可以通过指定key方便的获取value。
1、 HashMap实现类：是无序的（Hash是一种随机算法），针对Key是不可重复的，若放相同的Key，
新的entry会替换老的entry；针对value没有限制（可重复）。
2、 TreeMap实现类：针对key是自然排序，不可重复，若key重复，新的entey会替换老的entry。针对value没有限制（可重复）。
package com.oop.ch07.test;
import java.util.Map.*;
import java.util.*;
import org.junit.Test;
import com.oop.ch07.Dept;
/*
* 练习map集合的使用：HashMap、TreeMap
*/
public class MapTest {
/**
* 练习HashMap
*/
@Test
public void testHashMap() {
Map<Object, Object> map = new HashMap<Object, Object>();
map.put("k1","k1的值");
map.put("k2","k2的值");
map.put("k3","k3的值");
map.put("k4","k4的值");
map.put("k3","k3的新值");
map.put("k5","k3的值");
//通过key获取该entry中的value
System.out.println(map.get("k3"));
//entry的个数
System.out.println("entry的个数:" + map.size());
//map.keySet()：将Map集合中所有entry的key都获取并放置到Set集合中
Set<Object> keySets = map.keySet();
for (Object key : keySets) {
//针对放置了Map集合中所有Key的Set集合进行遍历，可以取到Key值，再通过get(Object Key)方法获取到对应的value
System.out.println("键：" + key + "，值：" + map.get(key));
}
//entrySet()：将Map集合中的所有entry（key和Value）一次性取出来放到一个Set集合中，
//再通过entry的getKey和getValue方法，获取到Map集合中放置的Key和value
//Entry<Object, Object>：相当于一个object
System.out.println();
Set<Entry<Object, Object>> entrySet = map.entrySet();
for (Entry<Object, Object> entry : entrySet) {
System.out.println("键：" + entry.getKey() + "，值：" + entry.getValue());
}
//containsKey(Object key):Map集合的Key中是否包含key,包含为true
System.out.println(map.containsKey("k2"));
//containsValue(Object value):Map集合的Value中是否包含value
System.out.println(map.containsValue("K2"));
}
/**
* 练习TreeMap
*/
@Test
public void testTreeMap() {
Map<Object, Object> map = new TreeMap<Object, Object>();
map.put("k1","k1的值");
map.put("k2","k2的值");
map.put("k3","k3的值");
map.put("k4","k4的值");
map.put("k3","k3的新值");
map.put("k5","k3的值");
//通过key获取该entry中的value
System.out.println(map.get("k3"));
//entry的个数
System.out.println("entry的个数:" + map.size());
//map.keySet()：将Map集合中所有entry的key都获取并放置到Set集合中
Set<Object> keySets = map.keySet();
for (Object key : keySets) {
//针对放置了Map集合中所有Key的Set集合进行遍历，可以取到Key值，再通过get(Object Key)方法获取到对应的value
System.out.println("键：" + key + "，值：" + map.get(key));
}
//entrySet()：将Map集合中的所有entry（key和Value）一次性取出来放到一个Set集合中，
//再通过entry的getKey和getValue方法，获取到Map集合中放置的Key和value
//Entry<Object, Object>：相当于一个object
System.out.println();
Set<Entry<Object, Object>> entrySet = map.entrySet();
for (Entry<Object, Object> entry : entrySet) {
System.out.println("键：" + entry.getKey() + "，值：" + entry.getValue());
}
//containsKey(Object key):Map集合的Key中是否包含key,包含为true
System.out.println(map.containsKey("k2"));
//containsValue(Object value):Map集合的Value中是否包含value
System.out.println(map.containsValue("K2"));
}
@Test
/*
* 在HashMap中放实体
*/
public void testHashMapEntity() {
Map<String,Dept> deptMap = new HashMap<String, Dept>();
deptMap.put("dept1", new Dept("人事部","北京"));
deptMap.put("dept2", new Dept("财务部","上海"));
deptMap.put("dept3", new Dept("公关部","昆明"));
deptMap.put("dept4", new Dept("综合部","山东"));
//打印一个value
System.out.println(deptMap.get("dept1"));
//使用entrySet遍历Map集合
System.out.println("使用entrySet遍历Map集合");
for (Entry<String, Dept> map : deptMap.entrySet()) {
System.out.println(map);
}
//使用keySet遍历集合
System.out.println("使用keySet遍历集合");
//Set<String> key = deptMap.keySet();
for (String map : deptMap.keySet()) {
System.out.println(map + "=" + deptMap.get(map));
}
}
}
实体类：
package com.oop.ch07;
/**
* 练习封装tb_dept表对应的实体类Dept 八种基本数据类型对应的有八种引用数据类型（包装数据类型）,
* byte short int long loat double char boolean
* Byte Short Integer Long Float Double Character Boolean
*
*/
public class Dept {
private Integer deptNo; // 部门编号
private String dName; // 部门名称
private String loc; // 部门所在地
//setter、getter方法的区域：
public void setDeptNo(Integer deptNo) {
this.deptNo = deptNo;
}
public Integer getDeptNo() {
return deptNo;
}
public void setDName(String dName) {
this.dName = dName;
}
public String getDName() {
return dName;
}
public void setLoc(String loc) {
this.loc = loc;
}
public String getloc() {
return loc;
}
//构造方法的区域：
//默认的构造方法，当手动写了一个带参的构造方法，默认的就会失效
public Dept() {
}
//有参的构造方法
public Dept(Integer deptNo) {
this.deptNo = deptNo;
}
public Dept(String dName,String loc) {
this.dName = dName;
this.loc = loc;
}
public String method1() {
return null;
}
/*
* 重写toString()方法，在Object类中就定义过该方法，一个类若重写了toString()方法
* 当输出该类的对象信息时，就会以toString方法的格式输出该类中“属性名 = 属性值”的格式，更方便我们观察对象的属性信息
* 此方法不需要手动调用，而是在输出对象时，JVM会自动调用
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "Dept [deptNo=" + deptNo + ", dName=" + dName + ", loc=" + loc + "]";
}
}
五、 泛型：
在集合框架中默认放置的数据都是Object类型（让集合可以存放任何类型的数据），但实际运用过程中通常需要将类型具体化，
更利于代码的编写，因此Java提供了泛型来指定集合中放置数据的真实类型，以避免后期数据类型转换异常。