每日要点
折半查找(二分查找)
例子1:
public static <T extends Comparable<T>> int binarySearch(T[] array, T key) {
int start = 0;
int end = array.length - 1;
while (start <= end) {
int mid = (end - start) / 2 + start;
if (array[mid].equals(key)) {
return mid;
}
else if (array[mid].compareTo(key) > 0) {
end = mid - 1;
}
else {
start = mid + 1;
}
}
return -1;
}
public static <T> int binarySearch(T[] array, T key, Comparator<T> comp) {
int start = 0;
int end = array.length - 1;
while (start <= end) {
// int mid = (start + end) / 2; // 有溢出的风险
// int mid = (end - start) / 2 + start;
int mid = (start + end) >>> 1;
if (array[mid].equals(key)) {
return mid;
}
else if (comp.compare(array[mid], key) > 0) {
end = mid - 1;
}
else {
start = mid + 1;
}
}
return -1;
}
int a = 1300000000;
int b = 1000000000;
System.out.println(a + b); //溢出 (超出了int类型的表示范围)
Collections工具类
例子1:
List<String> list = new ArrayList<>();
list.add("banana");
list.add("grape");
list.add("banana");
list.add("apple");
list.add("");
list.add("zoo");
list.add("bear");
Collections.shuffle(list);
// Collections.fill(list, "apple");
for (String str : list) {
System.out.println(str);
}
System.out.println("============");
// Lambda表达式 ---> 闭包(closure)
Collections.sort(list, (o1, o2) -> {
return o2.length() - o1.length();
});
for (String str : list) {
System.out.println(str);
}
List<String> list2 = Collections.unmodifiableList(list);
System.out.println(list2.size());
list2.remove("apple");
list2.add("strawberry");
遗留容器
遗留容器 (自己写代码不要用但是可能在项目早期版本中可能遇到的容器)
所谓遗留容器就是在新版本中已经被淘汰的容器 - 设计烂、效率低、使用麻烦
BitSet ---> 二进制位集合
Vector --> ArrayList的线程安全版本
Stack ---> 栈 - FILO的容器 设计烂 不要继承工具类
Dictionary --> 字典 - 键值对容器
Hashtable ---> HashMap的线程安全版本
Properties ---> 键和值的类型都是String的HashMap
Enumeration ---> 枚举器 (对遗留容器进行迭代的迭代器)
例子1:
// 获得系统属性
Properties sysProps = System.getProperties();
for (Object key : sysProps.keySet()) {
System.out.println(key + ":" + sysProps.get(key).toString());
}
// 获得环境变量
Map<String, String> map = System.getenv();
for (String key : map.keySet()) {
System.out.println(key + "--" + map.get(key));
}
Properties props = new Properties();
try {
// 从文件中加载键值对到容器中
props.load(Test03.class.getClassLoader().getResourceAsStream("hello.ini"));
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(props.size());
for (Object key : props.keySet()) {
System.out.println(key + "--->" + props.getProperty((String) key));
}
Enumeration<Object> e = props.keys();
while (e.hasMoreElements()) {
String key = (String) e.nextElement();
System.out.println(key + "--->" + props.getProperty(key));
}
异常捕捉机制
try - 把可能在运行时出状况的代码放到try块中保护起来执行
如果出现了异常状况就通过后面的catch来捕获异常对象并进行相应的处理
FileInputStream的构造器用throws关键字声明了FileNotFoundException异常
而且该构造器的代码中判定如果文件无效就用throw关键字抛出异常
一个try块后面可以跟多个catch用于捕获不同的异常类型
但是在书写上要保证先捕获子类型异常再捕获父类型异常
如果捕获的异常之间没有父子关系那么捕获顺序随意
从Java 7开始如果多个catch代码是一致的可以合并为一个catch
打印异常栈轨迹 - 对于调试程序比较有帮助的一个方法
e.printStackTrace();
finally 总是执行代码块 - 不管程序正常异常此处都要执行
此处最适合释放程序中打开的各种外部资源(文件、数据库、网络)
例子1:
InputStream in = null;
// try - 把可能在运行时出状况的代码放到try块中保护起来执行
// 如果出现了异常状况就通过后面的catch来捕获异常对象并进行相应的处理
try {
// FileInputStream的构造器用throws关键字声明了FileNotFoundException异常
// 而且该构造器的代码中判定如果文件无效就用throw关键字抛出异常
in = new FileInputStream("c:/Java基础.jpg");
int data;
while ((data = in.read()) != -1) {
System.out.printf("%x ", data);
}
}
// 一个try块后面可以跟多个catch用于捕获不同的异常类型
// 但是在书写上要保证先捕获子类型异常再捕获父类型异常
// 如果捕获的异常之间没有父子关系那么捕获顺序随意
// 从Java 7开始如果多个catch代码是一致的可以合并为一个catch
catch (FileNotFoundException e) {
// 打印异常栈轨迹 - 对于调试程序比较有帮助的一个方法
e.printStackTrace();
}
catch (IOException e) {
e.printStackTrace();
}
// 总是执行代码块 - 不管程序正常异常此处都要执行
// 此处最适合释放程序中打开的各种外部资源(文件、数据库、网络)
finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
TWR语法
TWR - try-with-resources
从Java 7开始可以使用TWR语法将需要释放的外部资源直接放在try后的圆括号中
这样的话不管正常离开还是异常离开try块 外部资源会自动关闭
实现了AutoCloseable接口的外部资源对象可以使用TWR语法自动关闭
try (....) {}
输入、输出
IO.png
Unix - IO操作被简化成了文件
C++/Java - IO操作被抽象成了流 读数据 - 输入流 - read()
写数据 - 输出流 - write()
只有一个方向一个维度
字节输入、输出流
InputStream - 字节流(以字节为单位进行读取) - 二进制文件
三种方式输入:
- 第一种:
如果频繁的进行I/O操作会使用CPU的利用率非常低下
因为I/O操作会导致CPU产生I/O中断 CPU不能满负荷工作
例子1:
// try (InputStream in = new FileInputStream("c:/Java基础.jpg")) {
try (InputStream in = new FileInputStream("c:/git命令.txt")) {
// 如果频繁的进行I/O操作会使用CPU的利用率非常低下
// 因为I/O操作会导致CPU产生I/O中断 CPU不能满负荷工作
int data;
while ((data = in.read()) != -1) {
System.out.printf("%x ", data);
}
- 第二种:
例子2:
创建一个字节数组作为输入缓冲区 将文件中的数据直接读入缓冲区中
这种做法可以减少I/O中断的次数从而保证CPU能够不被频繁中断
文件太大不好
// 创建一个字节数组作为输入缓冲区 将文件中的数据直接读入缓冲区中
// 这种做法可以减少I/O中断的次数从而保证CPU能够不被频繁中断
// 文件太大不好
byte[] buffer = new byte[in.available()];
if (in.read(buffer) != -1) {
in.read(buffer);
for (byte b : buffer) {
System.out.printf("%02x ", b & 0xff);
}
}
- 第三种:
例子3:
byte[] buffer = new byte[1024];
int totalBytes; // 记录read操作总共读了多少字节
while ((totalBytes = in.read(buffer)) != -1) {
// System.out.println("\n读到了" + totalBytes + "个字节");
// for (int i = 0; i < totalBytes; i++) {
// System.out.printf("%02x ", buffer[i] & 0xff);
// }
System.out.print(new String(buffer, 0, totalBytes));
}
}
catch (IOException e) {
e.printStackTrace();
}
字符输入输出流
Reader - 字符流(以字符为单位进行读取) - 文本文件
例子1:
File file = new File("c:/git命令.txt");
try (Reader reader = new FileReader(file)){
/* int ch;
while ((ch = reader.read()) != -1) {
System.out.print((char) ch);
Thread.sleep(200);
}*/
/* char[] buffer = new char[(int) file.length()];
int totalChars = reader.read(buffer);
System.out.print(new String(buffer, 0, totalChars));*/
char[] buffer = new char[512];
int totalChars;
while ((totalChars = reader.read(buffer)) != -1) {
System.out.print(new String(buffer, 0, totalChars));
// Thread.sleep(1000);
}
}
catch (IOException e) {
e.printStackTrace();
}
输出流:
FileWriter构造器的第一个参数是文件名或者File对象
第二个参数用来指定是否启动追加模式(在原来文件的末尾输出新的内容)
Writer writer = new FileWriter("c:/abc.txt", true)
例子2:
String s1 = "Hello, world!";
String s2 = "你好, 世界!";
// FileWriter构造器的第一个参数是文件名或者File对象
// 第二个参数用来指定是否启动追加模式(在原来文件的末尾输出新的内容)
try (Writer writer = new FileWriter("c:/abc.txt", true)) {
writer.write(s1);
writer.write("\r\n");
writer.write(s2);
}
catch (IOException e) {
e.printStackTrace();
}
System.out.println("程序结束.");
作业
- 1.九九乘法表文件输出
try (Writer writer = new FileWriter("c:/qwe.txt")) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
writer.write(i + "*" + j + "=" + i * j + "\t");
}
writer.write("\r\n");
}
} catch (IOException e) {
e.printStackTrace();
}
- 2.写一个方法实现文件拷贝功能
public static void fileCopy(String source, String target) {
try (InputStream in = new FileInputStream(source);
OutputStream out = new FileOutputStream(target)){
byte[] buffer = new byte[1024];
int totalBytes;
while ((totalBytes = in.read(buffer)) != -1 ) {
out.write(buffer, 0, totalBytes);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
