JAVA高级特性
第一章:集合框架
List、Map是否都继承自Collection接口 ？
List，set继承于Collection
Map没有继承于Collection其相对是独立的，属于Collection类型的对象可以通过构造函数将一个集合构成另一个集合
和数组采用相同存储结构的集合类型是什么？
java.util.ArrayList和java.util.Vector.都是采用数组形式来实现的。
Iterator接口的作用是什么？
Iterator称之为迭代器，是去遍历Collection、Map集合中的元素对象。
Collections是什么？
提供了对集合进行排序、遍历等多种算法实现
详情见：https://blog.csdn.net/qq_39101581/article/details/88395381
集合框架图！！！:
1616995964485
Java集合框架包含的内容:
大致：
ollection:
1:List(不唯一、有序)，分为ArrayList集合，LinkedList集合
2:Set
具体：
Collection:接口存储一组不唯一，无序的对象
List:接口存储一组不唯一，有序（插入顺序）的对象 Set:接口存储一组唯一，无序的对象
Map:接口存储一组键值对象，提供key到value的映射
List接口的实现类：
List:
1:ArrayList
2:LinkedList
ArrayList:实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高
LinkedList:采用链表存储方式。插入、删除元素时效率比较高
ArrayList集合类的方法1:
通过List接口的实现类ArrayList实现需求
使用List接口提供的：add()、add(int index,Object o)、 size()、get(int index)方法
1:存储对象
1-1：再末尾添加元素
1-2:指定索引位置添加
2：获得集合长度
3：遍历集合数据
步骤一：
//宠物的父类
public abstract class Pet {
public String name = “无名氏”;// 昵称
public int health = 100;// 健康值
public int love = 0;// 亲密度
public Pet(String name) {
this.name = name;
}
//get set
public String getName() {
return name;
}
public int getHealth() {
return health;
}
public int getLove() {
return love;
}
//抽象吃饭方法
public abstract void eat(); //抽象方法eat(),负责宠物吃饭功能。
public void print() {
System.out.println("宠物的自白：n我的名字叫" + this.name +
"，健康值是" + this.health + "，和主人的亲密度是"
+ this.love + "。");
}
}
步骤二：狗狗继承父类重写吃饭方法
@Override
public void print(){
super.print(); //调用父类的print方法
System.out.println("我是一只 " + this.strain + “。”);
}
}
步骤三：
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
// 1、创建四个狗狗对象
Dog ououDog = new Dog(“欧欧”, “雪娜瑞”);
Dog yayaDog = new Dog(“亚亚”, “拉布拉多”);
Dog meimeiDog = new Dog(“美美”, “雪娜瑞”);
Dog feifeiDog = new Dog(“菲菲”, “拉布拉多”);
// 2、创建ArrayList集合对象并把四个狗狗对象放入其中
List dogs = new ArrayList();
dogs.add(ououDog);
dogs.add(yayaDog);
dogs.add(meimeiDog);
// 添加feifeiDog到指定位置
dogs.add(0,feifeiDog);
// 3、输出集合中狗狗的数量
System.out.println("共计有" + dogs.size() + "条狗狗。");
// 4、通过遍历集合显示各条狗狗信息
System.out.println("分别是:");
for (int i = 0; i }
}
输出结果:
共计有4条狗狗。
分别是:
菲菲 拉布拉多
欧欧 雪娜瑞
亚亚 拉布拉多
美美 雪娜瑞
ArrayList集合类的方法2:
使用List接口提供的remove()、contains()方法
1：删除对象
1-1：指定位置
1—2：删除指定的对象
2：判断集合是否包含此对象
public static void main(String[] args) {
// 1、创建多个狗狗对象
// 2、创建ArrayList集合对象并把多个狗狗对象放入其中
// 3、输出删除前集合中狗狗的数量
// 上面三步省略
//4、删除集合中第一个狗狗和feifeiDog狗狗
//从列表中删除指定位置元素
dogs.remove(0);
//删除指定对象
dogs.remove(feifeiDog);
//5、显示删除后集合中各条狗狗信息
System.out.println("n删除之后还有" + dogs.size() + "条狗狗。");
System.out.println("分别是:");
for (int i = 0; i < dogs.size(); i++) {
//强制类型转换
Dog dog = (Dog) dogs.get(i);
//通过对象获取名字和品种
System.out.println(dog.getName() + "t" + dog.getStrain());
}
//6、判断集合中是否包含指定狗狗信息
if(dogs.contains(meimeiDog)){
System.out.println("n集合中包含美美的信息");
}else{
System.out.println("n集合中不包含美美的信息");}
}
}
运行效果：
删除之前共计有4条狗狗。
删除之后还有2条狗狗。
分别是:
亚亚 拉布拉多
美美 雪娜瑞
ArrayList的基本使用(必须了解)
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(123);
list.add(“456”);
System.out.println(“---------初始数据------------------”);
for (int i = 0; i
System.out.println(list.get(i));
}
System.out.println("---------在列表的末尾顺序添加元素------------------");
list.add("789");
for (int i = 0; i
}
运行效果：
---------初始数据------------------
123
456
---------在列表的末尾顺序添加元素------------------
123
456
789
--------在指定的索引位置添加元素,例如在第一位添加-------------------
000
123
456
789
--------返回列表中的元素个数-------------------
4
--------判断列表中是否存在指定元素-------------------
false
true
-------从列表中删除指定位置元素,例如在第一位删除-------------------
123
456
789
-------从列表中删除元素,例如在456删除-------------------
true
123
789
-------将指定位置的元素替换为新元素------------------
[123, 666]
ArrayList<>泛型基本使用：
(涉及泛型，后面会讲解到)
public static void main(String[] args) {
//创建了一个ArrayList集合，集合的名称是list,里面装的全都是String字符串类型的数据
//备注：从JDK1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的
ArrayList list = new ArrayList<>();
//向集合中添加数据，需要用到add方法
list.add("赵丽颖");
list.add("迪丽热巴");
//可以直接用list输出，输出结果即为String类型
System.out.println("添加默认数据："+list);
//使用size,返回列表中的元素个数
System.out.println("添加默认数据："+list.size());
//在指定的索引位置添加元素
list.add(0,"牛啊牛啊");
//返回指定索引位置处的元素
System.out.println(list.get(0));
//判断列表中是否存在指定元素
System.out.println(list.contains("牛啊"));
System.out.println(list.contains("迪丽热巴"));
//从列表中删除元素
list.remove("迪丽热巴");
System.out.println("移除执行元素后的："+list);
//从列表中删除指定位置元素
System.out.println(list.remove(0));
System.out.println("根据索引移除后的："+list);
}
运行结果：
添加默认数据：[赵丽颖, 迪丽热巴]
添加默认数据：2
牛啊牛啊
false
true
移除执行元素后的：[牛啊牛啊, 赵丽颖]
牛啊牛啊
根据索引移除后的：[赵丽颖]
List接口常用方法！！！：
方法名 说 明
boolean add(Object o) 在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o) 在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size() 返回列表中的元素个数
Object get(int index) 返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o) 判断列表中是否存在指定元素
boolean remove(Object o) 从列表中删除元素
Object remove(int index) 从列表中删除指定位置元素，起始索引位置从0开始
LinkedList集合类?对象使用
插入、删除操作频繁时，可使用LinkedList来提高效率
LinkedList提供对头部和尾部元素进行添加和删除操作的方法
！//省略狗狗类
public static void main(String[] args) {
// 1、创建多个狗狗对象
Dog ououDog = new Dog(“欧欧”, “雪娜瑞”);
Dog yayaDog = new Dog(“亚亚”, “拉布拉多”);
Dog meimeiDog = new Dog(“美美”, “雪娜瑞”);
Dog feifeiDog = new Dog(“菲菲”, “拉布拉多”);
// 2、创建LinkedList集合对象并把多个狗狗对象放入其中
LinkedList dogs = new LinkedList();
dogs.add(ououDog);
dogs.add(yayaDog);
//插入、删除操作频繁时，可使用LinkedList来提高效率
//在集合的首部添加元素
dogs.addFirst(feifeiDog);
//在集合的末尾添加元素
dogs.addLast(meimeiDog);
// 3、查看集合中第一条狗狗的昵称
Dog dogFirst=(Dog)dogs.getFirst();
System.out.println("第一条狗狗的昵称是"+dogFirst.getName()+"。" );
// 4、查看集合中最后一条狗狗的昵称
Dog dogLast=(Dog)dogs.getLast();
System.out.println("最后一条狗狗的昵称是"+dogLast.getName()+"。" );
//插入、删除操作频繁时，可使用LinkedList来提高效率
// 5、删除集合中第一个狗狗和最后一个狗狗
dogs.removeFirst();
dogs.removeLast();
// 6、显示删除部分狗狗后集合中各条狗狗信息
System.out.println("n删除部分狗狗后还有" + dogs.size() + "条狗狗。");
System.out.println("分别是:");
for (int i = 0; i < dogs.size(); i++) {
Dog dog = (Dog) dogs.get(i);
System.out.println(dog.getName() + "t" + dog.getStrain());
}
}
运行结果：
第一条狗狗的昵称是菲菲。
最后一条狗狗的昵称是美美。
删除部分狗狗后还有2条狗狗。
分别是:
欧欧 雪娜瑞
亚亚 拉布拉多
LinkedList的基本使用方法
//基本使用：
public static void main(String[] args) {
LinkedList dogs = new LinkedList();
dogs.add(0,“1”);
dogs.add(1,“2”);
dogs.add(2,“3”);
System.out.println(“初始数据:”);
System.out.println(dogs+“n”);
//在列表的首部添加元素
dogs.addFirst("0");
//在列表的末尾添加元素
dogs.addLast("4");
System.out.println("添加后查看数据:");
System.out.println(dogs+"n");
System.out.println("查看添加后下标为0的第一条数据:"+dogs.get(0));
System.out.println("查看添加后下标为4的最后一条数据:"+dogs.get(4)+"n");
System.out.println("返回列表中的第一个元素");
System.out.println(dogs.getFirst());
System.out.println("返回列表中的最后一个元素");
System.out.println(dogs.getLast()+"n");
System.out.println("删除并返回列表中的元素");
System.out.println(dogs.removeFirst());
System.out.println("删除并返回列表中的最后一个元素");
System.out.print(dogs.removeLast()+"nn");
System.out.println("删除后查看数据:");
System.out.println(dogs+"n");
}
运行结果：
初始数据:
[1, 2, 3]
添加后查看数据:
[0, 1, 2, 3, 4]
查看添加后下标为0的第一条数据:0
查看添加后下标为4的最后一条数据:4
返回列表中的第一个元素
0
返回列表中的最后一个元素
4
删除并返回列表中的元素
0
删除并返回列表中的最后一个元素
4
java
删除后查看数据:
[1, 2, 3]
LinkedList的特殊方法！！！：
方法名 说 明
void addFirst(Object o) 在列表的首部添加元素
void addLast(Object o) 在列表的末尾添加元素
Object getFirst() 返回列表中的第一个元素
Object getLast() 返回列表中的最后一个元素
Object removeFirst() 删除并返回列表中的第一个元素
Object removeLast() 删除并返回列表中的最后一个元素
Set接口
Set接口存储一组唯一，无序的对象
HashSet是Set接口常用的实现类
Set中存放对象的引用
示例：
1:
Set set=new HashSet();
String s1=new String(“java”);
String s2=s1;
String s3=new String(“JAVA”);
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set.size());
运行结果：
2
//因为s2和s1通过equals()方法对比是完全一样的所以输出2
2:
Set接口如何判断加入对象是否已经存在呢？
采用对象的equals()方法比较两个对象是否相等
示例：
Set set=new HashSet();
String s1=new String(“java”);
String s2=s1;
String s3=new String (“java”);
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set.size());
运行结果：
1
//因为s2和s1以及s3通过equals()方法对比两个对象是否相等是完全一样的所以输出1
3:
HashSet是Set接口常用的实现类
//省略车对象
public static void main(String[] args) {
Set newsTitleSet = new HashSet();
NewTitle car = new NewTitle(1, “汽车”, “管理员”);
//省略创建对象…
//增加元素
//省略增加元素…
newsTitleSet.add(car);
//获取元素个数
System.out.println(“新闻标题数目为：” + newsTitleList.size() + “条");
}
运行结果：
新闻标题数目为：1条
集合框架有何好处？
（1）使用集合类可以降低开发成本，而不用自己实现集合类。
（2）因为我们用的集合框架类是经过严格测试的，所以代码质量会得到提高。
（3）通过使用JDK附带的集合类，可以降低代码维护成本。
（4）复用性和可操作性。
java集合框架中包含哪些接口和类？
1、Collection：代表一组对象，每一个对象都是它的子元素。
2、Set：不包含重复元素的Collection。
3、List：有顺序的collection，并且可以包含重复元素。
4、Map：可以把键(key)映射到值(value)的对象，键不能重复。
ArrayList和LinkedList有何异同？
相同点：
ArrayList 和LinkedList 都是单列集合中List接口的实现类，它们都是存取允许重复，且有序的的元素。
不同点：
ArrayList查询快，增删慢
LinkedList查询慢，增删快
Map接口
引言：
Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作
最常用的实现类是HashMap
public static void main(String[] args) {
// 1、使用HashMap存储多组国家英文简称和中文全称的键值对
Map countries = new HashMap();
countries.put(“CN”, “中华人民共和国”);
countries.put(“RU”, “俄罗斯联邦”);
countries.put(“FR”, “法兰西共和国”);
countries.put(“US”, “美利坚合众国”);
// 2、显示"CN"对应国家的中文全称
System.out.println("------获取指定元素的值-------");
String country = (String) countries.get("CN");
System.out.println("CN对应的国家是:" + country);
// 3、显示集合中元素个数
System.out.println("------获取Map元素个数-------");
System.out.println("Map中共有"+countries.size()+"组数据");
System.out.println("------删除指定元素，判断是否包含指定元素-------");
System.out.println("Map中包含FR的key吗?" +
countries.containsKey("FR"));
countries.remove("FR");
System.out.println("Map中包含FR的key吗?" +
countries.containsKey("FR"));
System.out.println("--------显示键集、值集和键值对集---------");
System.out.println(countries.keySet());
System.out.println(countries.values());
System.out.println(countries);
System.out.println("----清空 HashMap并判断-----");
//清空集合数据
countries.clear();
//.isEmpty集合是否为空
if(countries.isEmpty()) {
System.out.println("已清空Map中数据！");
}
System.out.println(countries);
}
运行效果：
------获取指定元素的值-------
CN对应的国家是:中华人民共和国
------获取Map元素个数-------
Map中共有4组数据
------删除指定元素，判断是否包含指定元素-------
Map中包含FR的key吗?true
Map中包含FR的key吗?false
--------显示键集、值集和键值对集---------
[RU, CN, US]
[俄罗斯联邦, 中华人民共和国, 美利坚合众国]
{RU=俄罗斯联邦, CN=中华人民共和国, US=美利坚合众国}
----清空 HashMap并判断-----
已清空Map中数据！
{}
map简单使用：
public static void main(String[] args) {
Map map = new HashMap();
map.put(1,"第一个值");
map.put(2,"第二个值");
map.put(3,"第三个值");
map.put(4,"第四个值");
System.out.println(map);
System.out.println("根据键返回相关联的值，如果不存在指定的键，返回null:t"+map.get(1));
System.out.println("删除由指定的键映射的“键-值对:t"+map.remove(1));
System.out.println("返回元素个数:t"+map.size());
System.out.println("返回键的集合:t"+map.keySet());
System.out.println("返回值的集合"+map.values());
System.out.println("如果存在由指定的键映射的“键”，返回true:t"+map.containsKey(2));
System.out.println("如果不存在由指定的键映射的“键”，返回false:t"+map.containsKey(5));
System.out.println("如果存在由指定的键映射的“值对”，返回true:t"+map.containsValue("第四个值"));
System.out.println("如果不存在由指定的键映射的“值对”，返回false:t"+map.containsValue("奇奇怪怪"));
}
运行效果：
{1=第一个值, 2=第二个值, 3=第三个值, 4=第四个值}
根据键返回相关联的值，如果不存在指定的键，返回null: 第一个值
删除由指定的键映射的“键-值对: 第一个值
返回元素个数: 3
返回键的集合: [2, 3, 4]
返回值的集合[第二个值, 第三个值, 第四个值]
如果存在由指定的键映射的“键”，返回true: true
如果存在由指定的键映射的“键”，返回true: false
如果存在由指定的键映射的“值对”，返回true: true
如果存在由指定的键映射的“值对”，返回true: false
Map接口常用方法
方法名 说 明
Object put(Object key, Object val) 以“键-值对”的方式进行存储
Object get (Object key) 根据键返回相关联的值，如果不存在指定的键，返回null
Object remove (Object key) 删除由指定的键映射的“键-值对”
int size() 返回元素个数
Set keySet () 返回键的集合
Collection values () 返回键的集合
boolean containsKey (Object key) 如果存在由指定的键映射的“键-值对”，返回true
使用Iterator和增强型for循环遍历Map集合
实现思路：
方法1：通过迭代器Iterator实现遍历
获取Iterator ：Collection 接口的iterator()方法
Iterator的方法
boolean hasNext(): 判断是否存在另一个可访问的元素
Object next(): 返回要访问的下一个元素
方法2：增强for循环
省略狗类和狗类的父类代码
public static void main(String[] args) {
//1:创建多个狗狗对象
Dog dogOne = new Dog(“第1只狗名字”,“拉布拉多”);
Dog dogTwo = new Dog(“第2只狗名字”,“萨摩耶”);
Dog dogThree = new Dog(“第3只狗名字”,“金毛”);
Dog dogFour = new Dog(“第4只狗名字”,“泰迪”);
//创建Map集合对象并且把多个狗狗放入其中
Map map = new HashMap();
map.put(dogOne.getName(),dogOne);
map.put(dogTwo.getName(),dogTwo);
map.put(dogThree.getName(),dogThree);
map.put(dogFour.getName(),dogFour);
//通过迭代器以此输出集合中所有狗狗的信息
System.out.println("使用Iterator遍历，所有狗狗的昵称和品种是：");
//取出所有的Key集合
Set keys = map.keySet();
//获取Iterator对象
Iterator it = keys.iterator();
//判断是否存在另一个可访问的元素
while(it.hasNext()){
//取出所有的key
String key = (String) it.next();
//取出对应的key的值
Dog o = (Dog)map.get(key);
System.out.println(key+"t"+o.getStrain());
}
System.out.println("使用foreach语句输出集合中所有狗狗的信息");
for (Object m:keys) {
Dog o =(Dog)map.get(m);
System.out.println(m+o.getStrain());
}
}
运行结果：
使用Iterator遍历，所有狗狗的昵称和品种是：
第2只狗名字 萨摩耶
第1只狗名字 拉布拉多
第3只狗名字 金毛
第4只狗名字 泰迪
使用foreach语句输出集合中所有狗狗的信息
第2只狗名字萨摩耶
第1只狗名字拉布拉多
第3只狗名字金毛
第4只狗名字泰迪
小结：
迭代器Iterator：
Set keys=dogMap.keySet(); //取出所有key的集合
Iterator it=keys.iterator(); //获取Iterator对象
while(it.hasNext()){
String key=(String)it.next(); //取出key
Dog dog=(Dog)dogMap.get(key); //根据key取出对应的值
System.out.println(key+“t”+dog.getStrain());
}
增强for循环语法：
for(元素类型t 元素变量x : 数组或集合对象){
引用了x的java语句
}
示例：
Set keys=dogMap.keySet(); //取出所有key的集合
for (Object m:keys) {
//这里不是泛型需要强制类型转换
Dog o =(Dog)map.get(m);
System.out.println(m+o.getStrain());
}
如何使用泛型集合？
引言：JDK1.5使用泛型改写了集合框架中的所有接口和类
如何解决以下强制类型转换时容易出现的异常问题?
List的get(int index)方法获取元素
Map的get(Object key)方法获取元素
Iterator的next()方法获取元素
示例：
狗类省略
Dog ououDog = new Dog(“欧欧”, “雪娜瑞”);
Dog yayaDog = new Dog(“亚亚”, “拉布拉多”);
Dog meimeiDog = new Dog(“美美”, “雪娜瑞”);
Dog feifeiDog = new Dog(“菲菲”, “拉布拉多”);
List dogs = new ArrayList();//标记元素类型
dogs.add(ououDog);
dogs.add(yayaDog);
dogs.add(meimeiDog);
// 添加feifeiDog到指定位置
dogs.add(2, feifeiDog);
//出现编译错误,元素类型不是Dog。
//dogs.add("hello");
//无需类型强制转换
Dog dog3 = dogs.get(2);
System.out.println("第三个狗狗的信息如下:");
System.out.println(dog3.getName() + "t" + dog3.getStrain());
System.out.println("使用foreach语句遍历dogs对象");
System.out.println("n所有狗狗的信息如下：");
for(Dog dog:dogs){
//无需类型强制转换
System.out.println(dog.getName() + "t" + dog.getStrain());
}
}
运行结果：
第三个狗狗的信息如下:
菲菲 拉布拉多
使用foreach语句遍历dogs对象输出所有狗狗的信息如下：
欧欧 雪娜瑞
亚亚 拉布拉多
菲菲 拉布拉多
美美 雪娜瑞
Dog ououDog = new Dog(“欧欧”, “雪娜瑞”);
Dog yayaDog = new Dog(“亚亚”, “拉布拉多”);
Dog meimeiDog = new Dog(“美美”, “雪娜瑞”);
Dog feifeiDog = new Dog(“菲菲”, “拉布拉多”);
//标记键类型 标记键-值类型
Map dogMap=new HashMap();
dogMap.put(ououDog.getName(),ououDog);
dogMap.put(yayaDog.getName(),yayaDog);
dogMap.put(meimeiDog.getName(),meimeiDog);
dogMap.put(feifeiDog.getName(),feifeiDog);
System.out.println("使用Iterator遍历，所有狗狗的昵称和品种分别是：");
//取出所有key的集合
//标记键类型
Set keys=dogMap.keySet();
//获取Iterator对象
//标记键类型
Iterator it=keys.iterator();
while(it.hasNext()){
//取出key
//无需类型转换
String key=it.next();
//根据key取出对应的值
//无需类型转换
Dog dog=dogMap.get(key);
System.out.println(key+"t"+dog.getStrain());
}
System.out.println("使用foreach语句输出集合中所有狗狗的信息");
for(String key:keys){
//无需类型强制转换
Dog dog=dogMap.get(key);
//根据key取出对应的值
System.out.println(key+"t"+dog.getStrain());
}
}
运行结果：
使用Iterator遍历，所有狗狗的昵称和品种分别是：
菲菲 拉布拉多
亚亚 拉布拉多
欧欧 雪娜瑞
美美 雪娜瑞
使用foreach语句输出集合中所有狗狗的信息
菲菲 拉布拉多
亚亚 拉布拉多
欧欧 雪娜瑞
美美 雪娜瑞
泛型基本使用:
<>中放的必须是引用数据类型，像自定义的类，包装类等等.
泛型集合中可以添加类和子类对象.
示例：
public static void main(String[] args) {]
//list
List list = new ArrayList<>();//创建一个String类型的泛型集合类
list.add(“a”);
list.add(“b”);
Iterator it = list.iterator();//获取指定泛型类的迭代器
while (it.hasNext()) {
System.out.println(it.next());
}
//map
//标记键类型
Set keys=dogMap.keySet();
//获取Iterator对象
//标记键类型
Iterator it=keys.iterator();
while(it.hasNext()){
//取出key
//无需类型转换
String key=it.next();
//根据key取出对应的值
//无需类型转换
Dog dog=dogMap.get(key);
System.out.println(key+"t"+dog.getStrain());
}
}
详情见:https://blog.csdn.net/qq_41055045/article/details/86771132https://blog.csdn.net/qq_41055045/article/details/86771132
泛型使用注意事项
引言： 前后泛型必须一致，或者后面的泛型可以省略不写.数组也要保证前后数据类型一致.
//泛型
List list = new ArrayList();//必须一致
//或者不写(1.7jdk版本之后，棱形泛型)
List list = new ArrayList<>();
//数组
int[] arr = new int[5];//必须一致
//错误示范数据类型不一致
List list = new ArrayList();
int[] arr = new byte[5];
例外：包装类Integer 标记Map的键类型
Map
集合框架总结
Collection集合（不唯一，无序）：
List集合（不唯一、有序）：
ArrayList集合
LinkedList集合
Set集合（唯一、无序）
ArrayList和LinkedList:
存储方式：
ArrayList：长度可变的数组，存储空间连续
LinkedList集合：链表式结构存储
执行效率：
ArrayList：遍历和随机访问效率高
LinkedList集合：插入和删除效率高
遍历集合的方法：
增强for循环遍历
迭代器Iterator遍历
