16Java多线程之线程调度
15Java多线程之生命周期和状态
14Java多线程之介绍
13JavaIO流
File
介绍
File:文件和目录(文件夹)路径名的抽象表示形式
IO流操作中大部分都是对文件的操作,所以Java就提供了File类供我们来操作文件
构造方法
1 | public File(String pathname):通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 |
1 | public class FileDemo { |
File类功能
更多功能详见 API。
1 | A:创建功能: |
1 | /* |
1 | /* |
1 | /* |
1 | /* |
1 | /* |
1 | /* |
案例
A:输出指定目录下指定后缀名的文件名称
a:先获取所有的,在遍历的时候判断,再输出
b:先判断,再获取,最后直接遍历输出即可
B:批量修改文件名称
案例A
1 | /* |
1 | /* |
案例B:
1 | /* |
递归
方法定义中调用方法本身的现象
注意事项
A:要有出口,否则就是死递归
B:次数不能过多,否则内存溢出
C:构造方法不能递归使用
案例
A:递归求阶乘
B:兔子问题
C:递归输出指定目录下所有指定后缀名的文件绝对路径
D:递归删除带内容的目录(小心使用)
案例A:
案例B:
1 | /** |
案例C:
1 | /** |
案例D:
1 | /** |
流
作用
IO流用来处理设备之间的数据传输(上传文件和下载文件)。
Java对数据的操作的通过流的方式。
Java用于操作流的对象都在IO包中。
流的分类
一般我们在讨论IO流的时候,如果没有明确说明按照什么分,默认按照数据类型分。
A:数据流向(方向)
输入流 读取数据
输出流 写出数据
B:数据类型(单位)
字节流(操作二进制文件,用Windows记事本打开读不懂的文件,英文也可以用字节流)
字节输入流 InputStream
|– FileInputStream
|– BufferedInputStream
字节输出流 OutputStream
|– FileOutputStream
|– BufferedOutputStream
字符流(操作文本文件,用Windows记事本打开能读懂的文件,包括中文、英文等各国语言)
字符输入流 Reader
|– InputStreamReader
|– FileReader
|– BufferedReader
字符输出流 Writer
|– OutputStreamWriter
|– FileWriter
|– BufferedWriter
C:功能
节点流,管道流(处理流)
输入流与输出流的区别
1).无论文件是否存在,输出流会自动创建文件。而输入流不会自动创建文件。
2).输出流有flush()方法,输入流没有此方法。
图解
字节流
FileOutputStream
构造方法
没有无参构造,必须要知道往哪里写
1 | public FileOutputStream(File file) :创建一个向指定 File 对象表示的文件中写入数据的文件输出流。参数:file - 为了进行写入而打开的文件。、 |
成员方法
1 | public void write(int b): 将指定字节写入此文件输出流。参数:b - 要写入的字节。 |
操作步骤
1:创建字节输出流对象
2:写数据,调用write()方法
3:释放资源
1 | /* |
1 | /* |
FileInputStream
构造方法
没有无参构造,必须要知道从哪里写
1 | public FileInputStream(File file):通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象 file 指定。 |
成员方法
1 | public int read():一次读一个字节,换行符号也能读到。读完后指针将指向下一个字节,有点类似迭代器的next()方法。 |
操作步骤
1:创建字节输入流对象
2:读数据,调用read()方法,并把数据显示到控制台
3:释放资源
1 | public class FileInputStreamDemo { |
案例
使用2种方式实现
A:复制文本文件
B:复制图片
C:复制视频
1 | // 一次读一个字节,太慢了 |
这一次复制中文确没有乱码,为什么?
上一次我们出现问题的原因在于我们每次获取到一个字节数据,就把该字节数据转换为了字符数据,然后输出到控制台。而现在,通过IO流读取数据,写到文本文件,你读取一个字节,我就写入一个字节,你没有做任何的转换。它会自己做转换,两个字节拼接成一个字符。看下面代码。
1 | /* |
1 | // 一次读一个字节数组,效率高 |
案例B:复制图片,只能用字节流
1 | // 一次读一个字节,太慢了 |
1 | // 一次读一个字节数组,效率高 |
案例C:复制视频
1 | // 一次读一个字节,太慢了 |
1 | // 一次读一个字节数组,效率高 |
字节缓冲区流
字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多,这是加入了数组这样的缓冲区效果,java本身在设计的时候,也考虑到了这样的设计思想(装饰设计模式),所以提供了字节缓冲区流(带缓冲区的字节类)这种类被称为:缓冲区类(高效类)
构造方法可以指定缓冲区的大小,但是我们一般用不上,因为默认缓冲区大小就足够了。
为什么不传递一个具体的文件或者文件路径,而是传递一个OutputStream对象呢?
原因很简单,字节缓冲区流仅仅提供缓冲区,为高效而设计的。但是呢,真正的读写操作还得靠基本的流对象实现。
A:BufferedOutputStream字节缓冲输出流,写入数据。该类实现缓冲的输出流。通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必针对每次字节写入调用底层系统。
构造方法:
public BufferedOutputStream(OutputStream out):创建一个新的缓冲输出流,以将数据写入指定的底层输出流。
public BufferedOutputStream(OutputStream out, int size):创建一个新的缓冲输出流,以将具有指定缓冲区大小的数据写入指定的底层输出流。
B:BufferedInputStream字节缓冲输入流,读取数据。在创建 BufferedInputStream 时,会创建一个内部缓冲区数组。(看API)
构造方法:
public BufferedInputStream(InputStream in):创建一个 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。创建一个内部缓冲区数组并将其存储在 buf 中。
public BufferedInputStream(InputStream in, int size):创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。
创建一个长度为 size 的内部缓冲区数组并将其存储在 buf 中。
1 | public class BufferedOutputStreamDemo { |
1 | /* |
案例
4种实现
A:复制文本文件
B:复制图片
C:复制视频
案例C:
1 | /* |
字符流
介绍
字节流操作中文数据不是特别的方便,所以就出现了转换流。转换流的作用就是把字节流转换字符流来使用。
转换流其实是一个字符流。
字符流 = 字节流 + 编码表
编码表
就是由字符和对应的数值组成的一张表。
1、计算机只能识别二进制数据,早期由来是电信号。为了方便应用计算机,让它可以识别各个国家的文字,就将各个国家的文字用数字来表示,并一 一对应,形成一张表。
ASCII:美国标准信息交换码。用一个字节的7位可以表示。
ISO-8859-1:拉丁码表,欧洲码表。用一个字节的8位表示。
GB2312:中国的中文编码表。
GBK:中国的中文编码表升级,融合了更多的中文文字符号。
GB18030:GBK的取代版本
BIG-5码 :通行于台湾、香港地区的一个繁体字编码方案,俗称”大五码”。地区标准号为:CNS11643,这就是人们讲的BIG-5码。
Unicode:国际标准码,融合了多种文字。所有文字都用两个字节来表示,Java语言使用的就是unicode
UTF-8:最多用三个字节来表示一个字符。
UTF-8不同,它定义了一种”区间规则”,这种规则可以和ASCII编码保持最大程度的兼容:
它将Unicode编码为00000000-0000007F的字符,用单个字节来表示
它将Unicode编码为00000080-000007FF的字符用两个字节表示
它将Unicode编码为00000800-0000FFFF的字符用3字节表示
2、字符串中的编码问题
编码:把能看懂的变成看不懂的
String – byte[]:使用String的构造方法
public byte[] getBytes(Charset charset):使用给定的 charset (字符集)将此 String 编码到 byte 序列,并将结果存储到新的 byte 数组。
解码:把看不懂的变成能看懂的
byte[] – String:使用String的成员方法
public String(byte[] bytes, String charsetName):通过使用指定的 charset (字符集)解码指定的 byte 数组,构造一个新的 String。
1 | /* |
IO流中的编码问题
编码问题其实很简单,编码只要一致即可
1 | public class OutputStreamWriterDemo { |
OutputStreamWriter
字符流通向字节流的桥梁。按指定字符集写入字符
构造方法:
public OutputStreamWriter(OutputStream out):创建使用默认字符编码的 OutputStreamWriter。
public OutputStreamWriter(OutputStream out, String charsetName):创建使用指定字符集的 OutputStreamWriter。指定编码。
成员方法:
public void write(int c):写入单个字符。
public void write(char[] cbuf):写入字符数组。是父类中的方法
public void write(char[] cbuf, int off, int len):写入字符数组的某一部分。
public void write(String str):写入字符串。是父类中的方法
public void write(String str, int off, int len):写入字符串的某一部分。
1 | /* |
InputStreamReader
字节流通向字符流的桥梁。按照指定字符集读取字符
构造方法:
public InputStreamReader(InputStream in):创建一个使用默认字符集的 InputStreamReader。
public InputStreamReader(InputStream in, String charsetName):创建使用指定字符集的 InputStreamReader。
成员方法:
public int read():读取单个字符。返回:读取的字符,如果已到达流的末尾,则返回 -1 。一次读取一个字符
public int read(char[] cbuf):将字符读入数组。返回:读取的字符数,如果已到达流的末尾,则返回 -1。是父类中的方法。一次读取一个字符数组
public int read(char[] cbuf, int offset, int length):将字符读入数组中的某一部分。返回:读取的字符数,如果已到达流的末尾,则返回 -1 。
1 | public class InputStreamReaderDemo { |
FileWriter和FileReader
1 | /* |
字符缓冲流
A: BufferedWriter:字符缓冲输出流。将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。 可以指定缓冲区的大小,或者接受默认的大小。在大多数情况下,默认值就足够大了。
构造方法:
public BufferedWriter(Writer out):创建一个使用默认大小输出缓冲区的缓冲字符输出流。
public BufferedWriter(Writer out, int sz):创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
特殊方法:
public void newLine():写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义,并且不一定是单个新行 (‘\n’) 符。
B: BufferedReader:字符缓冲输入流。从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。可以指定缓冲区的大小,或者可使用默认的大小。大多数情况下,默认值就足够大了。
构造方法:
public BufferedReader(Reader in):创建一个使用默认大小输入缓冲区的缓冲字符输入流。
public BufferedReader(Reader in, int sz):创建一个使用指定大小输入缓冲区的缓冲字符输入流。
特殊方法:
public String readLine():读取一个文本行。通过下列字符之一即可认为某行已终止:换行 (‘\n’)、回车 (‘\r’) 或回车后直接跟着换行。
返回:包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null。
1 | public class BufferedWriterDemo { |
1 | public class BufferedReaderDemo { |
1 | /* |
1 | /* |
案例
复制文本文件(5种方式)
数据操作流
数据操作流(操作基本类型数据的流)(理解)
一、可以操作基本类型的数据
二、流对象名称
DataInputStream
DataOutputStream
1 | /* |
内存操作流
内存操作流
一、有些时候我们操作完毕后,未必需要产生一个文件,就可以使用内存操作流。例如:从数据库中取出二进制的文件,会用到 ByteArrayInputStream 。
二、三种
A:ByteArrayInputStream,ByteArrayOutputStream
ByteArrayInputStream:包含一个内部缓冲区,该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。
关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用,而不会产生任何 IOException。
B:CharArrayReader,CharArrayWriter
C:StringReader,StringWriter
1 | /* |
打印流(掌握)
一、字节打印流,字符打印流
二、特点:
A:只操作目的地,不操作数据源
B:可以操作任意类型的数据
C:如果启用了自动刷新,在调用println()方法的时候,能够换行并刷新
D:可以直接操作文件
问题:哪些流可以直接操作文件呢?
看API,如果其构造方法能够同时接收File和String类型的参数,一般都是可以直接操作文件的
三、复制文本文件
1 | public class PrintWriterDemo { |
1 | /* |
1 | /* |
1 | /* |
标准输入输出流
一、System类下面有这样的两个字段
in 标准输入流
out 标准输出流
二、三种键盘录入方式
A:main方法的args接收参数
B:System.in通过BufferedReader进行包装
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
C:Scanner
Scanner sc = new Scanner(System.in);
三、输出语句的原理和如何使用字符流输出数据
A:原理
System.out.println(“helloworld”);
PrintStream ps = System.out;
ps.println(“helloworld”);
B:把System.out用字符缓冲流包装一下使用
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
1 | /* |
1 | /* |
1 | /* |
随机访问流
一、RandomAccessFile类,可以按照文件指针的位置读写数据。
RandomAccessFile类既不是InputStream类的子类,也不是OutputStream类的子类。习惯上,仍然呈RandomAccessFile类创建的对象为一个流。RandomAccessFile流的指向既可以作为源也可以作为目的地。换句话说,当想对一个文件进行读写操作时,可以创建一个指向该文件的RandomAccessFile流,这样既可以从这个流读取文件的数据,也可以通过这个流向文件写入数据。
RandomAccessFile类的两个构造方法:
RandomAccessFile(String name, String mode):参数name用来确定一个文件名,给出创建的流的源(也是流的目的地)。参数mode取”r”(只读)或”rw”(可读写),决定创建的流对文件的操作权限。
RandomAccessFile(File file, String mode):参数file是一个File对象,给出创建的流的源(也是流的目的地)。参数mode取”r”(只读)或”rw”(可读写),决定创建的流对文件的操作权限。创建对象时应捕获IOException异常。
RandomAccessFile流对文件的读写方式更为灵活。因为以下两个方法:
public void seek(long pos):设置到此文件开头测量到的文件指针偏移量,在该位置发生下一个读取或写入操作。偏移量的设置可能会超出文件末尾。偏移量的设置超出文件末尾不会改变文件的长度。只有在偏移量的设置超出文件末尾的情况下对文件进行写入才会更改其长度。 参数: pos - 从文件开头以字节为单位测量的偏移量位置,在该位置设置文件指针。
public long getFilePointer():返回此文件中的当前偏移量。返回:到此文件开头的偏移量(以字节为单位),在该位置发生下一个读取或写入操作。
RandomAccessFile类的常用方法有:
public native long getFilePointer():获取当前流在文件中的读写位置。
public native long length():获取文件的长度。
public final byte readByte():从文件中读取一个字节。
public final double readDouble():从文件中读取一个双精度浮点值(8个字节)。
public final int readInt():从文件中读取一个int值(4个字节)。
public final String readLine():从文件中读取一个文本行。
public final String readUTF():从文件中读取一个UTF字符串。
public void seek(long pos):定位当前流在文件中的读写的位置。
public void write(byte b[]):写b.length个字节到文件。
public final void writeDouble(double v):向文件写入一个双精度浮点值。
public final void writeInt(int v):向文件写入一个int值。
public final void writeUTF(String str):写入一个UTF字符串。
二、案例:
A:写数据
B:读数据
C:获取和改变文件指针的位置
1 | /* |
合并流
一、把多个输入流的数据写到一个输出流中。
二、构造方法:
A:SequenceInputStream(InputStream s1, InputStream s2)
B:SequenceInputStream(Enumeration<? extends InputStream> e)
1 | /* |
1 | /* |
序列化流(理解)
一、可以把对象写入文本文件或者在网络中传输
二、如何实现序列化呢?
让被序列化的对象所属类实现序列化接口。
该接口是一个标记接口。没有功能需要实现。
三、注意问题:
把数据写到文件后,在去修改类会产生一个问题。
如何解决该问题呢?
在类文件中,给出一个固定的序列化id值。
而且,这样也可以解决黄色警告线问题
四、
什么时候序列化?
如何实现序列化?
什么是反序列化?
1 | /* |
Properties
一、Properties是一个集合类,Hashtable的子类
1 | /* |
二、特有功能
A:public Object setProperty(String key,String value):添加元素
B:public String getProperty(String key):获取元素
C:public Set<String> stringPropertyNames():获取所有键的集合
1 | public class PropertiesDemo2 { |
三、和IO流结合的方法
把键值对形式的文本文件内容加载到集合中,(把文件中的数据读取到集合中)
public void load(Reader reader)
public void load(InputStream inStream)
把集合中的数据存储到文本文件中
public void store(Writer writer,String comments)
public void store(OutputStream out,String comments)
1 | /* |
四、案例:
A:根据给定的文件判断是否有键为”lisi”的,如果有就修改其值为100
B:写一个程序实现控制猜数字小游戏程序不能玩超过5次
案例A:
1 | /* |
案例B:
1 | /* |
NIO
一、JDK4出现NIO。
新IO和传统的IO有相同的目的,都是用于进行输入输出的,但新IO使用了不同的方式来处理输入输出,采用内存映射文件的方式,将文件或者文件的一段区域映射到内存中,就可以像访问内存一样的来访问文件了,这种方式效率比旧IO要高很多,但是目前好多地方我们看到的还是旧IO的引用。
JDK4新IO要了解的类(看API)
Buffer(缓冲),Channer(通道)
二、JDK7的NIO的使用
Path:与平台无关的路径。
Paths:包含了返回Path的静态方法。
public static Path get(URI uri):根据给定的URI来确定文件路径。
Files:操作文件的工具类。提供了大量的方法,简单了解如下方法
public static long copy(Path source, OutputStream out) :复制文件
public static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption… options):把集合的数据写到文件。
1 | public class NIODemo { |
11Java正则表达式
推荐:
重用正则总结
1 | ([a-zA-Z -]*)([0-9]*) # 利用捕获组匹配,可匹配字符串示例:"abc90"、"90",第一组为字符串(空或abc),第二组为数字(90)。 |
正则表达式
定义
- 正则表达式定义了字符串的模式。
- 正则表达式可以用来搜索、编辑或处理文本。
- 正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别。
转义
- 在 Java 中,
\\
表示:我要插入一个正则表达式的反斜线,所以其后的字符具有特殊意义。 - 在其他语言中(如Perl),一个反斜杠
\
就足以具有转义的作用,而在 Java 中则需要有两个反斜杠才能被解析为其他语言中的转义作用。 - Java 的正则表达式中,两个
\\
代表其他语言中的一个\
,这也就是为什么表示一位数字的正则表达式是\\d
,而表示一个普通的反斜杠是\\\\
。
常用元字符
^
、 $
、 *
、 +
、 ?
、 [a-z]
、 \w
、 \W
、 {n, m}
常见规则
1 | A:字符 |
String类
String 类中有几个可以使用正则的方法,实际都是通过调用 Pattern、Matcher 类实现的
1 | // 判断功能 |
Pattern和Matcher类
Pattern 类:正则表达式的编译表示,没有公共构造方法。
使用方法:正则表达式字符串先被编译为此类的实例,然后用得到的 Pattern 对象创建 Matcher 对象。执行 matcher 方法后的所有匹配都驻留在匹配器 Matcher 中,所以多个匹配器可以共享同一模式。
1 | public static Pattern compile(String regex) // 将给定的正则表达式编译成一个模式。 |
Matcher 类:没有公共构造方法。
通过解释 Pattern 对字符序列执行匹配操作的引擎。
匹配器通过调用 Pattern 的 matcher 方法创建一个 Matcher 对象。创建后,Matcher 可用于执行三种不同类型的匹配操作:
- matches 方法尝试将整个输入序列与模式匹配。
- lookingAt 方法尝试将输入序列与模式匹配,从头开始。
- find 方法扫描输入序列以查找与模式匹配的下一个子序列。
每个方法都返回一个表示成功或失败的布尔值。通过查询匹配器的状态可以获取关于成功匹配的更多信息。
如果匹配成功,则可以通过 start、end 和 group 方法获取更多信息。
1 | public boolean matches():尝试将整个区域与模式匹配。 |
PatternSyntaxException 类:一个非强制异常类,它表示一个正则表达式模式中的语法错误。
具体使用说明及更多方法见 API。
典型调用顺序
1 | Pattern p = Pattern.compile("a*b"); // 正则表达式字符串先被编译为Pattern实例。 |
练习
1 | /* |
捕获组
- 捕获组是把多个字符当一个单独单元进行处理的方法,它通过对括号内的字符分组来创建。
- 捕获组是通过从左至右计算其开括号来编号。例如,在表达式
((A)(B(C)))
,有四个这样的组:((A)(B(C)))
、(A)
、(B(C))
、(C)
。 - Matcher 类的 groupCount 方法返回一个 int 值,表示 Matcher 对象有多个捕获组。
- group(0) 是一个特殊的组,代表整个表达式。该组不包括在 groupCount 的返回值中。
用法:
1 | public class RegexDemo { |
输出:
1 | Found value: This order was placed for QT3000! OK? |
正则注入(regex injection)
定义
攻击者可能会通过恶意构造的输入对初始化的正则表达式进行修改,比如导致正则表达式不符合程序规定要求;可能会影响控制流,导致信息泄露,或导致ReDos攻击。
避免使用不可信数据构造正则表达式。
利用方式
- 匹配标志:不可信的输入可能覆盖匹配选项,然后有可能会被传给
Pattern.compile()
方法。 - 贪赞:一个非受信的输入可能试图注入一个正则表达式,通过它来改变初始的那个正则表达式,从而匹配尽可能多的字符串,从而暴露敏感信息。
- 分组:程序员会用括号包括一部分的正则表达式以完成一组动作中某些共同的部分。攻击者可能通过提供非受信的输入来改变这种分组。
输入校验
- 非受信的输入应该在使用前净化,从而防止发生正则表达式注入。
- 当用户必须指定正则表达式作为输入时,必须注意需要保证初始的正则表达式没有被无限制修改。
- 在用户输入字符串提交给正则解析之前,进行白名单字符处理 (比如字母和数字)。
- 开发人员必须仅仅提供有限的正则表达式功能给用户,从而减少被误用的可能。
ReDos攻击
正则表达式拒绝服务( ReDoS ) 是一种算法复杂性攻击,它通过提供 正则表达式
或 需要很长时间评估的输入
来产生拒绝服务(即:通过提供特制的正则表达式或输入来使程序花费大量时间,消耗系统资源,然后程序将变慢或变得无响应)。
ReDos攻击概述
- JDK 中提供的正则匹配使用的是 NFA 引擎。
- NFA 引擎具有回溯机制(一个字符可能尝试多次匹配),匹配失败时花费时间很大。 正则表达式回溯法原理
- 当使用简单的非分组正则表达式时,是不会导致ReDos攻击的。
潜在危险
- 包含具有自我重复的重复性分组的正则
举例:^(\d+)+$
、^(\d*)*$
、^(\d+)*$
、^(\d+|\s+)*$
- 包含替换的重复性分组
举例:^(\d|\d|\d)+$
、^(\d|\d?)+$
当输入字符串为
1111111111111111111111x1
时,正则表达式^(\d+)+$
就会不断进行失败重试,从而耗死CPU计算。解析:
\d+
表示匹配一个或多个数字;()+
表示分组本身也匹配一个或多个;那么匹配字符串1111111111111111111111x1
就会进行非常多的尝试,从而导致CPU资源枯竭。
规避猎施
- 进行正则匹配前,先对匹配的文本的长度进行校验。
- 在编写正则时,尽量不要使用过于复杂的正则,越复杂越容易有缺陷。
- 在编写正则时,尽量减少分组的使用。
- 避免动态构建正则(因为难以判断是否有性能问题),当使用不可信数据构造正则时,要使用白名单进行严格校验。
案例
校验qq号码
1 | /* |
用正则表达式改进:
1 | public class RegexDemo { |
校验电话号码和邮箱
按照不同的规则分割数据
一:
1 | /* |
二:
1 | /* |
三:
1 | /* |
把论坛中的数字替换为*
1 | /* |
获取字符串中由3个字符组成的单词
1 | /* |
09Java常用类4之集合
常用集合结构
线性结构
- List:ArrayList、CopyOnWriteArrayList、Vector
- Queue: LinkedList、PriorityQueue、BlockingQueue、ConcurrentLinkedQueue
- Stack:extends from Vector
非线性结构
- Set:HashSet、LinkedHashSet、TreeSet、CopyOnWriteArraySet、ConcurrentSkipListSet
- Map:HashMap、TreeMap、WeakHashMap、IdentityHashMap、 LinkedHashMap 、 HashTable、ConcurrentHashMap、 ConcurrentSkipListMap
集合包装类
集合包装类可以对上述的几种结构进行包装,而它在其中的返回会加入它的语义理解
- 不可变更集合类:Collections.unmodifiableCollection,对上述结构的限定,返回不可修改的集合
- 同步集合类:Collections.synchronizedCollection,可以将任意List转换成线程安全的List
- 可检查集合类:Collections.checkedCollection
注:其中 斜体 标注的类为线程安全类。
线性存储结构
重点选讲以 List
展开的类
ArrayList
- 可设置初始的空间大小,在底层数组不够用时在原来的基础上扩容1.5倍
Vector
- 可设置初始的空间大小,在底层数组不够用时在原来的基础上默认扩容2倍 (亦可设置增长的空间大小)
- 读写方法都加了synchronized关键字,是线程安全的
CopyOnWriteArrayList
- 利用写时复制的思想,一旦碰到写操作都会对所有元素进行复制
- 在新的数组上修改后,重新对数组赋值引用,保证线程安全
- 适合读多写少的应用场景
ConcurrentLinkedQueue
- 非阻塞式队列,利用CAS算法保证入队出队线程安全
- 进行元素遍历时是线程不安全
- 不允许添加null元素
映射关系
WeakHashMap
- 适用于需要缓存的场景,对entry进行弱引用管理
- GC时会自动释放弱引用的entry项
- 相对HashMap只增加弱引用管理,并不保证线程安全
HashTable
- 读写方法都加了synchronized关键字
- key和value都不允许出现null值
- 与HashMap不同的是HashTable直接使用对象的hashCode,不会重新计算hash值
ConcurrentHashMap
- 利用CAS+ Synchronized来确保线程安全
- 底层数据结构依然是数组+链表+红黑树
- 对哈希项进行分段上锁,效率上较之HashTable要高
- key和value都不允许出现null值
问题:
为什么ConcurrentHashMap不允许插入Null值?
小测
ArrayList list = new ArrayList(20);
中的 List 扩充了几次?
初始化时直接分配大小,不存在扩充情况,所以是0次;add等操作时才可能会发生扩充。
08Java常用类3
Math类
包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。
1、针对数学运算进行操作的类
2、常见方法(更多方法见API)
1 | 成员变量: |
案例:
A:猜数字小游戏
B:获取任意范围的随机数
1 | /* |
Random类
1.用于产生随机数的类
如果用相同的种子创建两个 Random 实例,则对每个实例进行相同的方法调用序列,它们将生成并返回相同的数字序列。
2.构造方法:
A:Random():创建一个新的随机数生成器。此构造方法将随机数生成器的种子设置为某个值,该值与此构造方法的所有其他调用所用的值完全不同。
没有给种子,用的是默认种子,是当前时间的毫秒值,每次产生的随机数不同
B:Random(long seed): 使用单个 long 种子创建一个新的随机数生成器。该种子是伪随机数生成器的内部状态的初始值,该生成器可通过方法 protected int next(int bits) 维护。
指定种子,每次种子相同,随机数就相同
3.成员方法:
A:int nextInt() 返回int范围内的随机数
1 | // nextInt方法源码 |
B:int nextInt(int n) 返回[0,n)范围内的随机数
1 | public class RandomDemo { |
System类
1.System 类包含一些有用的 类 字段和方法。System 类不能被实例化。
在 System 类提供的设施中,有标准输入、标准输出和错误输出流;对外部定义的属性和环境变量的访问;加载文件和库的方法;还有快速复制数组的一部分的实用方法。
解析:说明字段和方法都是跟类相关的,跟类相关不就是静态的么,说明没有构造方法。
2.成员方法(更多方法见API)
1 | A: public static void gc():运行垃圾回收器 |
案例:
A. 运行垃圾回收器
System.gc()可用于垃圾回收。当使用System.gc()回收某个对象所占用的内存之前,通过要求程序调用适当的方法来清理资源。在没有明确指定资源清理的情况下,Java提高了默认机制来清理该对象的资源,也就是调用Object类的finalize()方法。finalize()方法的作用是释放一个对象占用的内存空间时,会被JVM调用。而子类重写该方法,就可以清理对象占用的资源,该方法没有链式调用,所以必须手动实现。
从程序的运行结果可以发现,执行System.gc()前,系统会自动调用finalize()方法清除对象占有的资源,通过super.finalize()方式可以实现从下到上的finalize()方法的调用,即先释放自己的资源,再去释放父类的资源。
但是,不要在程序中频繁的调用垃圾回收,因为每一次执行垃圾回收,jvm都会强制启动垃圾回收器运行,这会耗费更多的系统资源,会与正常的Java程序运行争抢资源,只有在执行大量的对象的释放,才调用垃圾回收最好
1 | public class RandomDemo { |
B. 退出jvm
public static void exit(int status)
终止当前正在运行的 Java 虚拟机。参数用作状态码;根据惯例,非 0 的状态码表示异常终止。
该方法调用 Runtime 类中的 exit 方法。该方法永远不会正常返回。
调用 System.exit(n) 实际上等效于调用:
Runtime.getRuntime().exit(n)
C. 获取当前时间的毫秒值
1 | public class SystemDemo { |
D. 数组复制
1 | public class SystemDemo { |
BigInteger类
大数字
a. java.math.BigInteger:整数
b. java.math.BigDecimal:浮点数
1、针对大整数的运算(BigInteger:可以让超过Integer范围内的数据进行运算)
2、构造方法
A:BigInteger(String s)
1 | public class BigIntegerDemo { |
3、成员方法(更多方法见API)
A: public BigInteger add(BigInteger val):加
B: public BigInteger subtract(BigInteger val):减
C: public BigInteger multiply(BigInteger val):乘
D: public BigInteger divide(BigInteger val):除
E: public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组
1 | public class BigIntegerDemo { |
BigDecimal类
1 | /* |
1、浮点数据做运算,会丢失精度。所以,针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)
2、构造方法
A:BigDecimal(String s)
3、成员方法:
A: public BigDecimal add(BigDecimal augend):加
B: public BigDecimal subtract(BigDecimal subtrahend):减
C: public BigDecimal multiply(BigDecimal multiplicand):乘
D: public BigDecimal divide(BigDecimal divisor):除
E: public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode):商,几位小数,如何舍取
divisor - 此 BigDecimal 要除以的值。
scale - 要返回的 BigDecimal 商的标度。
roundingMode - 要应用的舍入模式。
F: public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode):商,几位小数,如何舍取
1 | public class BigDecimalDemo { |
日期相关类
A. java.util.Date类:最常用的功能为获得系统的当前时间。
B. java.util.Calendar类:与日历相关的类。可以获得日期相关的信息,还可以进行日期的计算。
C. java.text.DateFormat及其子类:可以对String与Date进行相互的转换。
1 | /*********************************************************************/ |
Date
类 Date 表示特定的瞬间,精确到毫秒。
A:构造方法
public Date():创建自 1970 年 1 月 1 日 00:00:00 GMT 到当前的默认毫秒值的日期对象
public Date(long time):创建自 1970 年 1 月 1 日 00:00:00 GMT 到给定的毫秒值的日期对象
1 | public class DateDemo { |
B:成员方法
public long getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
public void setTime(long time):设置此 Date 对象,以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
1 | public class DateDemo { |
C:日期和毫秒值的相互转换
案例:你来到这个世界多少天了?
1 | /* |
DateFormat
针对日期进行格式化和针对字符串进行解析的类,但是是抽象类,所以使用其子类SimpleDateFormat
A: SimpleDateFormat的构造方法:
public SimpleDateFormat():用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
public SimpleDateFormat(String pattern): 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
这个模式字符串该如何写呢? 通过查看API,我们就找到了对应的模式
y 年
M 年中的月份
d 月份中的天数
H 一天中的小时数(0-23)
m 小时中的分钟数
s 分钟中的秒数
yyyy-MM-dd HH:mm:ss 2017-05-01 12:12:12
yyyy年MM月dd日 HH:mm:ss 2017年05月01日 12:12:12
B:日期和字符串的转换
a:Date – String(格式化)
public final String format(Date date)
b:String – Date(解析)
public Date parse(String source)
1 | public class DateFormatDemo { |
C:制作了一个针对日期操作的工具类。
日期类的时间从为什么是从1970年1月1日
I suspect that Java was born and raised on a UNIX system.
UNIX considers the epoch (when did time begin) to be midnight, January 1, 1970.
是说java起源于UNIX系统,而UNIX认为1970年1月1日0点是时间纪元.
但这依然没很好的解释”为什么”,出于好奇,继续Google,总算找到了答案:
http://en.wikipedia.org/wiki/Unix_time
这里的解释是:
最初计算机操作系统是32位,而时间也是用32位表示。
System.out.println(Integer.MAX_VALUE);
2147483647
Integer在JAVA内用32位表 示,因此32位能表示的最大值是2147483647。
另外1年365天的总秒数是31536000,
2147483647/31536000 = 68.1
也就是说32位能表示的最长时间是68年,而实际上到2038年01月19日03时14分07
秒,便会到达最大时间,过了这个时间点,所有32位操作系统时间便会变为
10000000 00000000 00000000 00000000
也就是1901年12月13日20时45分52秒,这样便会出现时间回归的现象,很多软件便会运行异常了。
到这里,我想问题的答案已经出来了:
因为用32位来表示时间的最大间隔是68年,而最早出现的UNIX操作系统考虑到计算
机产生的年代和应用的时限综合取了1970年1月1日作为UNIX TIME的纪元时间(开始
时间),而java自然也遵循了这一约束。
至于时间回归的现象相信随着64为操作系统的产生逐渐得到解决,因为用64位操作
系统可以表示到292,277,026,596年12月4日15时30分08秒,相信我们的N代子孙,哪
怕地球毁灭那天都不用愁不够用了,因为这个时间已经是千亿年以后了。
最后一个问题:上面System.out.println(new Date(0)),打印出来的时间是8点而非0点,
原因是存在系统时间和本地时间的问题,其实系统时间依然是0点,只不过我的电脑时区
设置为东8区,故打印的结果是8点。
Calendar类
它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段 之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。
1、日历类,封装了所有的日历字段值,通过统一的方法根据传入不同的日历字段可以获取值。
2、如何得到一个日历对象呢?
Calendar rightNow = Calendar.getInstance();// 使用默认时区和语言环境获得一个日历。返回的 Calendar 基于当前时间,使用了默认时区和默认语言环境。
本质返回的是子类对象
3、成员方法
A: public int get(int field):返回给定日历字段的值。日历类中的每个日历字段都是静态的成员变量,并且是int类型
B: public void add(int field,int amount): 根据日历的规则,为给定的日历字段添加或减去指定的时间量。
C: public final void set(int year,int month,int date): 设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。
1 | public class CalendarDemo { |
- 案例:
1 | /* |
二分查找(二分法)
查找:
基本查找:数组元素无序(从头找到尾)
二分查找(折半查找):数组元素有序
数组高级二分查找原理图解:
代码:
注意:下面这种做法是有问题的。
因为数组本身是无序的,所以这种情况下的查找不能使用二分查找。
所以你先排序了,但是你排序的时候已经改变了我最原始的元素索引。
必须使用基本查找,除非需求不在意。