J2EE集合框架之list
1.了解UML
1.1什么是UML:
UML 是统一建模语言的简称，它是一种由一整套图表组成的标准化建模语言。UML用于帮助系统开发人员阐明，展示，构建和记录软件系统的产出。UML代表了一系列在大型而复杂系统建模中被证明是成功的做法，是开发面向对象软件和软件开发过程中非常重要的一部分。UML主要使用图形符号来表示软件项目的设计，使用UML可以帮助项目团队沟通、探索潜在的设计和验证软件的架构设计。以下我们将向您详细介绍什么是UML、UML的历史以及每个UML图类型的描述，辅之以UML示例。
1.2使用UML的目的：
- 为用户提供现成的、有表现力的可视化建模语言，以便他们开发和交换有意义的模型。
- 为核心概念提供可扩展性和特殊化机制。
- 独立与特定的编程语言和开发过程。
- 为了解建模语言提供一个正式的基础。
- 鼓励面向对象工具市场的发展。
- 支持更高层次的开发概念，如：协作、框架，模式和组件。
- 整合最佳的工作方法。
1.3UML图表：
UML图表主要分为结构性图表和行为性图表，结构性图表包括：类图、组件图、部署图、对象图、包图、复合结构图、轮廓图；行为性图表包括：用例图、活动图、状态机图、序列图、通讯图、交互概述图、时序图。
UML图表关系如图所示：
2.集合框架：
2.1什么是集合框架及集合框架的内容：
集合框架是为了表示和操作集合而规定的一种统一的标准体系结构。
集合框架包括三大块内容：
（1）接口：表示集合的抽象数据类型，在图中虚线表示，如：Collect、list、Set、Map、lterator。
（2）实现：集合框架接口的具体表现。在图中虚线框表示，粗实现框表示最常用的实现，如：ArrayList、LinkedList、HashMap、HashSet。
（3）算法：在一个实现某个集合框架中的接口的对象身上完成某种有用的计算方法。
2.2集合框架体系图：
简化图：
集合框架关系图：
3.List集合：
3.1List 集合的特点：
不唯一：其元素以线性方式存储，集合中可以存放重复对象。
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
// 实例化list集合
List<String> list = new ArrayList<String>();
// 向集合中添加元素
list.add("木易");
list.add("三金");
list.add("君易");
list.add("木易");
// 打印输出集合
System.out.println(list);
}
}
输出结果（如图所示）：
有序：存取元素的顺序一致
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
// 实例化list集合
List<String> list = new ArrayList<String>();
// 向集合中添加元素
list.add("木易");
list.add("三金");
list.add("君易");
list.add("木易");
// 打印输出集合
System.out.println(list);
}
}
输出结果：
3.2list集合的遍历方式：
3.2.1Iterator接口遍历：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
// 多态的方式实例化list集合
List<String> list = new ArrayList<String>();
// 向集合中添加元素
list.add("木易");
list.add("三金");
list.add("君易");
list.add("木易");
// 输出查看集合
System.out.println(list);
// 使用Iterator接口遍历：
Iterator<String> it = list.iterator();
while (it.hasNext()) {// 判断是否包含迭代元素
// 有，则输出迭代元素
System.out.println(it.next());
}
}
}
输出的迭代元素结果：（如图所示）：
3.2.2 普通for循环遍历：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
// 多态的方式实例化list集合
List<String> list = new ArrayList<String>();
// 向集合中添加元素
list.add("木易");
list.add("三金");
list.add("君易");
list.add("木易");
// 输出查看集合
System.out.println(list);
// 普通for循环遍历
for (int i = 0; i < list.size(); i++) {// 集合下标从0开始，遍历长度小于集合的长度
// 通过get方法传递索引获取集合中对应下标的数据信息
System.out.println(list.get(i));
}
}
}
for循环输出结果：（如图所示）：
3.2.3 增强for循环遍历：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
// 多态的方式实例化list集合
List<String> list = new ArrayList<String>();
// 向集合中添加元素
list.add("木易");
list.add("三金");
list.add("君易");
list.add("木易");
// 输出查看集合
System.out.println(list);
// 增强for循环遍历
for (String string : list) { // string接受集合数据，通过遍历一一打印输出
// 输出集合数据
System.out.println(string);
}
}
}
增强for输出的结果：（如图所示）：
3.2.4 List集合自带的迭代器遍历：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
// 多态的方式实例化list集合
List<String> list = new ArrayList<String>();
// 向集合中添加元素
list.add("木易");
list.add("三金");
list.add("君易");
list.add("木易");
// 输出查看集合
System.out.println(list);
// list集合自带的迭代器遍历
ListIterator<String> listit=list.listIterator();
while(listit.hasNext()) {//判断是否包含list迭代元素
//包含则输出集合元素数据
System.out.println(listit.next());
}
}
}
list集合自带迭代器输出结果（如图所示）：
3.2.5 Lambda遍历:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
// 多态的方式实例化list集合
List<String> list = new ArrayList<String>();
// 向集合中添加元素
list.add("木易");
list.add("三金");
list.add("君易");
list.add("木易");
// 输出查看集合
System.out.println(list);
//5、Lambda
list.forEach(
item -> System.out.println(item)
);
}
}
Lambda遍历结果（如图所示）：
3.3 list集合子类的特点：
3.3.1 ArrayList:
底层数据结构我数组，查询修改数据快，增加修改慢。
3.3.2 LinkedList:
底层数据结构是链表，查询和修改慢，增删快
3.3.3 二者的区别：
- ArrayList的实现是基于数组，LinkedList的实现是基于双向链表。
- 对于随机访问，ArrayList优于LinkedList
- 对于插入和删除操作，LinkedList优于ArrayList
- LinkedList比ArrayList更占内存，因为LinkedList的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。
3.4 list集合增长因子论证：（list调优）
package com.YX;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
public class Demo {
public static void main(String[] args) throws Exception {
List list = new ArrayList();
for (int i = 0; i < 100; i++) {
System.out.print(i+"==");
list.add(i);
elementDataLength(list);
}
}
public static void elementDataLength(List list) throws Exception {
Field ed = list.getClass().getDeclaredField("elementData");
ed.setAccessible(true);
Object[] o = (Object[]) ed.get(list);
System.out.println("当前List集合容量为："+o.length);
}
}
按住ctrl点击如图所示的函数：
就会跳转至原方法中（如下图所示）：
向集合中添加元素就是向elementData[size++]的数组中在对应下标添加。
上图所示的方法是为论证图下数组的长度变化
打印语句输出如图所示
总结：List底层结构是数组结构 它是一个’可变数组’，一旦超过默认数组长度，会自动扩容 增长因子为0.5。如图上所示，List默认长度10，当数据增加至11条时 长度由10增加至15。我们可以通过调控集合的默认长度和增长因子量来实现集合调优的效果。
3.5 list集合去重复：
案例1：创建对象是字符串(contains去重复)
打印结果：
contains比较的是字符串内容和字符串所在内存地址的数值，所以在一定程度上contains方法去重复具有缺陷，无法应用在字符串对象包含的内容，因为字符串对象是new关键字创建的，代表着开辟了新的内存空间。
解决方法：调用equals方法去重复。
案例2：调用equals方法去重复
package com.YX;
import java.util.ArrayList;
public class Demo3 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new book(1, "西游记"));
list.add(new book(2, "水浒传"));
list.add(new book(3, "红楼梦"));
if (!list.contains(new book(3, "红楼梦"))) {// contains去重复
list.add(new book(3, "红楼梦"));
}
// 遍历输出集合
for (Object obj : list) {
System.out.println(obj);
}
}
}
class book {
private int bid;
private String bname;
public book() {
// TODO Auto-generated constructor stub
}
public book(int bid, String bname) {
super();
this.bid = bid;
this.bname = bname;
}
@Override
public String toString() {
return "book [bid=" + bid + ", bname=" + bname + "]";
}
}
contains遍历集合结果
调用equals方法,代码如下：
package com.YX;
import java.util.ArrayList;
public class Demo3 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new book(1, "西游记"));
list.add(new book(2, "水浒传"));
list.add(new book(3, "红楼梦"));
if (!list.contains(new book(3, "红楼梦"))) {// contains去重复
list.add(new book(3, "红楼梦"));
}
// 遍历输出集合
for (Object obj : list) {
System.out.println(obj);
}
}
}
class book {
private int bid;
private String bname;
public book() {
// TODO Auto-generated constructor stub
}
public book(int bid, String bname) {
super();
this.bid = bid;
this.bname = bname;
}
@Override
public String toString() {
return "book [bid=" + bid + ", bname=" + bname + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + bid;
result = prime * result + ((bname == null) ? 0 : bname.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
System.out.println("被调用");
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
book other = (book) obj;
if (bid != other.bid)
return false;
if (bname == null) {
if (other.bname != null)
return false;
} else if (!bname.equals(other.bname))
return false;
return true;
}
}
equals打印结果：
