复习
1.Math
java.lang,数学类,类中成员都是静态的,因此通过类名直接访问。
max()/min()/round()/pow()…
random():随机数,double,0.0~1.0
new java.util.Random().nextDouble()
.nextInt(int n)
2.System
java.lang,系统类,类中成员静态的,因此通过类名直接访问。
属性:
in,out,err
方法:
exit(0)/currentTimeMillis()
3.时间日期对象
java.util.Date:
时间日期,精确到毫秒,类中大部分方法都已过时,被日历对象Calendar替代。
构造方法:
方法:
getTime()
setTime(毫秒值)
日期格式化对象:
java.text.DateFormat
--SimpleDateFormat(y,M,d, h/H, m,s)
format(Date)
parse(text)
Calendar:
getInstance()
get(字段名)
获取/设置毫秒值:
getTimeInMillis()
setTimeInMillis(毫秒值)
日历对象和日期对象互转:
Date getTime()
setTime(Date)
4.异常
-
异常的理解
a.程序出现错误,导致不能继续运行
b.不同的错误有对应的对象来描述,该对象中:异常名、原因、位置…
c.处理异常的一种机制 -
异常继承体系
Throwable
–Error
–Exception
–RuntimeException
异常:
编译时异常
运行时异常 -
jvm的默认处理异常的机制
哪行有问题会封装成对象,将对象逐级向上抛出,直至交给jvm,jvm采用默认处理,将错误的信息使用错误输出设备输出到控制台。 -
手动处理异常的方式
捕获try{}、catch(异常类型){}、finally{} try-catch try-catch-catch... try-catch-finally try-catch-catch...finally try-finally
声明或抛出
throws:异常类名,用在方法上,谁调用谁处理。 throw:异常对象,用在方法内
-
异常通用方法
构造方法、方法 -
自定义异常
步骤:
1.定义类继承Exception或RuntimeException
2.调用父类构造方法 -
继承时重写方法的注意事项
1、重写时父类方法有throws
2、重写时父类方法没有throws
课程
一. 集合概述
(一) 集合和数组的区别
- 相同点: 两者都是数据存储容器,可以存储多个数据
- 不同点:
数组:
1)数组的长度是不可变的,集合的长度是可变的
2)数组可以存基本数据类型和引用数据类型
集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类
(二) 集合体系结构
List :
- 元素存取有序
- 元素有索引
- 存储的元素可以重复
Set:
- 元素存取无序
- 没有索引
- 不存储重复元素
/*
* 集合框架:
* jdk1.2版本
* 集合: 容器,存储对象。
* 变量、数组、字符串缓冲区
* 集合和数组区别:
* 集合:
* 1.大小可变 2.存储不同类型的对象 3.只能存储引用类型数据
* 数组:
* 1.大小不可变 2.相同类型的数据 3.既可以存储基本也可以存储引用
*
* 单列:
* 多行一列,一个对象一个对象的存储。
* 根:
* Collection
* ---List :有序(存入的顺序和取出的顺序一致)可重复
* ---ArrayList
* ---LinkedList
* ---Set :无序(存入的顺序和取出的顺序不一定一致))不可重复
* ---HashSet
* ---TreeSet
* 容器有这么多,因为不同的容器,存储和取出数据的方式不同(底层算法不同,数据结构),针对不同的场景使用不同的容器。
*
*
* 双列:
* 多行两列,一对数据一对数据存储
* Map(映射)
* --HashMap
* --TreeMap
* */
二. 单列集合体系的详细讲解
(一) 顶层接口Collection常用功能
-
概述: Collection是单列集合的顶层接口,定义的是所有单列集合中共有的功能. JDK不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现.
-
创建Collection集合的对象:
Collection接口,不能直接创建对象,因此找一个实现类ArrayList创建对象
1)多态: 多态的方式 – 父类引用指向子类对象 Collection c = new ArrayList();
2)具体的实现类创建 – 本类引用指向本类对象 ArrayList a = new ArrayList(); -
Collection集合常用方法:
1)boolean add(Object e): 添加元素
2)boolean remove (Object o): 从集合中移除指定的元素
3)void clear(): 清空集合中的元素
4)boolean contains(Object o): 判断集合中是否存在指定的元素
5)boolean isEmpty(): 判断集合是否为空(集合存在,没有元素), 如果集合为空, 那么返回true, 如果集合不为空 false
6)int size(): 返回集合中元素的数量,返回集合的长度。
7)Object[] toArray(): 返回集合的对象的数组
import java.util.ArrayList;
import java.util.Collection;
public class Demo2 {
public static void main(String[] args) {
//创建集合容器
Collection coll = new ArrayList(); //多态
//添加
coll.add("abc");
coll.add(123); //自动装箱
coll.add(null);
coll.add(new Object());
//清空容器
//coll.clear();
//移除指定元素
//coll.remove(123);
//获取元素个数
//System.out.println(coll.size());
//判断是否包含指定元素
//System.out.println(coll.contains("abc"));
//判断容器是否为空,元素个数是否为0, 不空=false
//System.out.println(coll.isEmpty());
//带All的方法
Collection c = new ArrayList();
c.add("abc");
c.add("bcd");
c.add("cde");
//将c中的数据添加到coll中
System.out.println(coll.addAll(c));
//coll中是否包含c中的所有元素
System.out.println(coll.containsAll(c));
//将coll中与c中相同的元素,coll中删除
//System.out.println(coll.removeAll(c));
//取出两个容器中的相同元素存储到coll中,即去交集元素
System.out.println(coll.retainAll(c));
System.out.println(coll);
System.out.println(c);
}
}
/*
包:java.util
* 单列集合根接口:
* Collection:
* 接口中设计的方法应为围绕着:增 / 删 /改 /查。
* */
(二) 单列集合的遍历
2.1迭代器遍历
- 迭代: 更新换代, 从一个到下一个概念, 迭代相当于遍历的含义
- 迭代器: 专门对于单列集合进行遍历的对象, 称为迭代器
- 获取集合迭代器的方法
Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到 - Iterator中的常用方法:
- boolean hasNext(): 判断当前位置是否有元素可以被取出
- E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
- void remove(): 删除迭代器对象当前指向的元素
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo4 {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add(new Person("小明",18));
coll.add(new Person("小丽",19));
coll.add(new Person("小刚",20));
coll.add(new Person("小黑",21));
coll.add(new Person("小白",22));
Iterator it = coll.iterator();
while(it.hasNext()){
// System.out.println( ((Person)it.next()).name +"...."+ ((Person)it.next()).age);
// Object obj = it.next();
// Person p = (Person)obj;
Person p = (Person)it.next();
//System.out.println(p.name+"..."+p.age);
System.out.println(p);
}
}
}
class Person{
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
2.2增强for(foreach)遍历
-
概述:
1)增强for是JDK5之后出现的,其内部原理是一个Iterator迭代器
2)实现Iterable接口的类才可以使用迭代器和增强for简化数组和Collection集合遍历 -
格式:
for(集合/数组中元素的数据类型 变量名 : 集合/数组名){
// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo3 {
public static void main(String[] args) {
Collection coll= new ArrayList();
coll.add("abc01");
coll.add("abc02");
coll.add("abc03");
coll.add("abc04");
coll.add("abc05");
//遍历集合元素,将集合中的元素进行依次输出,在过程中可以对指定的元素进行操作。
//1.将集合转数组
/* Object[] objects = coll.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}*/
System.out.println("------------------------------------------");
//2.集合特有的方法遍历集合元素
//通过iterator,返回的一个迭代器,迭代器可以迭代取出Collection中的元素
Iterator it = coll.iterator(); //多态 接口类型的引用指向了自己的实现类对象
while(it.hasNext()){
//System.out.println(it.next());
Object obj = it.next();
String s = (String)obj; //向下转型
if(s.equals("abc02")){
//coll.add("999");
//coll.remove("abc02");
it.remove();
}
}
/*
* ConcurrentModificationException:并发修改异常
* 当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常。
* 如上述的代码:coll又要遍历(迭代器操作),又要添加元素(集合操作)
* 解决方式:
* 要么使用迭代器中的功能操作集合,要么使用集合中的方法操作和。
* */
System.out.println("-------------------------------------");
/*
for-each语句
作用:遍历数组或集合。
* for(元素类型 变量名:被遍历的对象){
* ...
* }
原理就是:迭代器Iterator
* */
for(Object object :coll){
System.out.println(object);
}
System.out.println(coll);
}
}
(三) 有序单列集合List
3.1概述
- 概述: List集合是Collection接口的子接口,其下有两个常用实现类分别为 ArrayList 和 LinkedList
- List集合特点:
1)有序:元素存入集合与从集合中取出的顺序一致
2)有索引:每个元素都有自己的索引编号,从0开始,到集合长度-1为止
3)元素可以重复:即使是值相同的几个元素,位置和索引也各不相同,可以区分这几个值 - List集合的特有方法:
- void add(int index,E element): 在此集合中的指定位置插入指定的元素
2)E remove(int index): 删除指定索引处的元素,返回被删除的元素
3)E set(int index,E element): 修改指定索引处的元素,返回被修改的元素
4)E get(int index):返回指定索引处的元素
import java.util.ArrayList;
import java.util.List;
public class Demo5 {
public static void main(String[] args) {
//创建List集合容器
List list = new ArrayList();
//添加元素
list.add("java01");
list.add("java02");
list.add("java03");
list.add("java03");
//在指定位置添加元素
//list.add(0,"abc01");
//根据索引获取元素
//System.out.println(list.get(10));
//根据索引,移除元素,并返回被移除的元素
//System.out.println(list.remove(0));
//根据索引,修改元素
//list.set(0,"999");
//注意:索引必须在,才能进行增删改查
System.out.println(list);
}
}
/*
* List:
* 有序的 collection(也称为序列)。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。
* 用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素。 索引值也是从0开始。
* 可以存储重复元素。
* 该接口中新增了一下方法,围绕着索引进行设计的。
* */
- 针对List集合特有的遍历方式
1)可以通过集合的size方法获取list集合索引的范围,根据索引通过get方法可以获取指定索引的值。
2)可以通过ListIterator迭代器,list专用,通过集合对象的listIterator()方法得到
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Demo6 {
public static void main(String[] args) {
List list = new ArrayList();
//添加元素
list.add("java01");
list.add("java02");
list.add("java03");
list.add("java04");
//1.转数组
Object[] objects = list.toArray();
for (int i = 0; i < objects.length; i++)
System.out.println(objects[i]);
System.out.println("---------------------------------------------------");
//2.迭代器 、
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("-----------------------------------------------------");
//3.for-each
for(Object obj:list)
System.out.println(obj);
System.out.println("----------------------------------------");
//4.普通for语句
for(int i =0 ; i < list.size(); i++)
System.out.println(list.get(i));
System.out.println("----------------------------------------");
//5.列表迭代器 注意:仅限于List使用。
ListIterator listIt = list.listIterator();
while(listIt.hasNext()) {
Object obj = listIt.next();
if(obj.equals("java02")){
//listIt.add("999"); //添加
//listIt.remove(); //移除
listIt.set("999"); //修改
}
}
System.out.println(list);
// while(listIt.hasPrevious())
// System.out.println(listIt.previous());
}
}
3.2 并发修异常的产生原因和解决办法
-
ConcurrentModificationException 并发修改异常
-
异常发生原因: 在迭代器遍历过程中使用集合的引用进行元素的添加或删除
-
解决方法:
(1) 通过for循环遍历集合,在遍历过程中可以进行添加和删除元素
(2) 使用迭代器中的remove()方法删除集合元素
(3) 使用List集合的特有迭代器ListIterator, 通过List中的方法listIterator()获取, 该迭代器允许迭代期间修改列表
– add(E e) 添加元素
– remove() 移除元素
案例 : 定义一个List集合, 存储字符串数据”ok”,”java”,”hello”,”world”, 迭代器遍历集合元素, 如果集合中存在”hello”字符串,向集合中添加”end”字符串
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo7 {
/*
* 定义一个List集合, 存储字符串数据”ok”,”java”,”hello”,”world”, 迭代器遍历集合元素,
* 如果集合中存在”hello”字符串,向集合中添加”end”字符串
* */
public static void main(String[] args) {
List list = new ArrayList();
list.add("ok");
list.add("java");
list.add("hello");
list.add("world");
//遍历
/*ListIterator it = list.listIterator();
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("hello"))
it.add("end");
}*/
for (int i = 0; i < list.size(); i++){
if(list.get(i).equals("hello")) {
list.add(i+1 , "end");
}
System.out.println(list.get(i));;
}
// System.out.println(list);
}
}
(四) 数据结构之栈和队列
数据结构是计算机存储,组织数据的方式,通常情况下, 精心选择的数据结构可以带来更高的运行和存储效率
4.1栈
栈: stack,又称堆栈,它是运算受限的线性表,其限制是仅允许在标的一端进行插入和删除操作,不允许在其他任何位置进行添加、查找、删除等操作。
特点: 先进后出,(即,存进去的元素,要在后它后面的元素依次取出后,才能取出该元素)。例如,子弹压进弹夹,先压进去的子弹在下面,后压进去的子弹在上面,当开枪时,先弹出上面的子弹,然后才能弹出下面的子弹。
压栈:就是存元素。即,把元素存储到栈的顶端位置,栈中已有元素依次向栈底方向移动一个位置。
弹栈:就是取元素。即,把栈的顶端位置元素取出,栈中已有元素依次向栈顶方向移动一个位置。
4.2队列
queue,简称队,它同堆栈一样,也是一种运算受限的线性表,其限制是仅允许在表的一端进行插入,而在表的另一端进行删除。
特点:
- 先进先出(即,存进去的元素,要在它前面的元素依次取出后,才能取出该元素)。例如,小火车过山洞,车头先进去,车尾后进去;车头先出来,车尾后出来。
- 队列的入口、出口各占一侧。例如,下图中的左侧为入口,右侧为出口
4.3数据结构之数组和链表
- 数组:
Array:是有序的元素序列,数组是在内存中开辟一段连续的空间,并在此空间存放元素。就像是一排出租屋,有100个房间,从001到100每个房间都有固定编号,通过编号就可以快速找到租房子的人。
特点查找元素快:
通过可以快速访问指定位置的元素
增删元素慢:
指定索引位置增加元素:需要创建一个新数组,将指定新元素存储在指定索引位置,再把原数组元素根据索引,复制到新数组对应索引的位置。如下图
指定索引位置删除元素:需要创建一个新数组,把原数组元素根据索引,复制到新数组对应索引的位置,原数组中指定索引位置元素不复制到新数组中。如下图
-
链表:linked list,由一系列结点node(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表,那么这里给大家介绍的是单向链表。
-
简单的说,采用该结构的集合,对元素的存取有如下的特点:
多个结点之间,通过地址进行连接。例如,多个人手拉手,每个人使用自己的右手拉住下个人的左手,依次类推,这样多个人就连在一起了。
查找元素慢:想查找某个元素,需要通过连接的节点,依次向后查找指定元素
增删元素快: 增加元素 --> 只需要修改连接下个元素的地址即可。
删除元素:只需要修改连接下个元素的地址即可。
4.4 ArrayList和LinkedList对比分析
- ArrayList集合:
(1) 在创建ArrayList集合对象的时候,会维护一个长度为10的Object类型的数组.
(2) 当插入数据10个长度不够,这时候以1.5倍的形式进行扩容
(3) 存储特点 : 查询快, 增删慢
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;
public class Demo8 {
public static void main(String[] args) {
Vector v = new Vector();
v.addElement("abc01");
v.addElement("abc02");
v.addElement("abc03");
v.addElement("abc04");
v.addElement("abc04");
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}
for (Enumeration e = v.elements(); e.hasMoreElements();)
System.out.println(e.nextElement());
new ArrayList<>().add("abc");
}
}
/*
* ArrayList:
* 是List接口的实现类。
* 底层采用的就是数组算法,适合做查询,线程不安全。
*
* Vector:
* jdk1.0版本的,底层也是可变数组实现,是一个线程安全对象。效率慢。
* ArrayList:
* jdk1.2版本的,底层也是可变数组实现,是一个线程不安全对象。效率高。
* */
- LinkedList:集合数据存储的结构是链表结构。方便元素添加、删除的集合。
LinkedList是一个双向链表,特点 : 查询慢, 增删快, 链表结构不需要连续内存空间, 可以利用内存中零散空间
实际开发中对一个集合元素的添加与删除经常涉及到首尾操作,而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可:
public void addFirst(E e):将指定元素插入此列表的开头。
public void addLast(E e):将指定元素添加到此列表的结尾。
public E getFirst():返回此列表的第一个元素。
public E getLast():返回此列表的最后一个元素。
public E removeFirst():移除并返回此列表的第一个元素。
public E removeLast():移除并返回此列表的最后一个元素。
import java.util.LinkedList;
public class Demo9 {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add("01");
list.add("02");
list.add("03");
list.add("04");
//在头和尾添加元素
list.addFirst("66");
list.addLast("88"); //jdk1.2 返回值类型是void
// list.offerFirst("99");
// list.offerLast("55"); jdk1.6 返回值类型是boolean
//头和尾的获取
// System.out.println(list.getFirst());
// System.out.println(list.getLast()); //jdk1.2 如果列表为空,获取时出现 NoSuchException异常
System.out.println(list.peekFirst());
System.out.println(list.peekLast()); //jdk1.6 如果列表为空,获取时返回null
//头和尾的删除 返回移除的元素
System.out.println(list.removeFirst()); //jdk1.2 如果列表为空,获取时出现 NoSuchException异常
System.out.println(list.removeLast());
// System.out.println(list.pollFirst());
// System.out.println(list.pollLast()); //jdk1.6 如果列表为空,获取时返回null
System.out.println(list);
}
}