本文围绕Java展开，介绍了异常处理机制，包括异常分类、捕获方式和自定义异常；阐述了集合相关知识，如List、Set、Map等集合的特点、实现原理和操作；还提及迭代器、泛型、断言等内容，如迭代器遍历元素时的注意事项，泛型的上下限和通配符等。
java基础11
异常
- 如果在主函数上抛出异常，表示将这个异常抛给了Java虚拟机，JVM默认打印异常的栈轨迹
- 异常对方法的重载没有影响
- 在try执行完前，无论出现了异常与否，finally都会执行一次。
- 在try-catch出现的情况下，JVM在编译的时候认为try不一定能够执行成功，就意味着try中不一定能够正 常返回结果
- 异常是Java中一套用于问题的反馈和处理的机制
- Throwable — 异常的顶级父类
- Error — 错误表示合理（语法上还是逻辑上都是成立的）的应用程序中出现了严重的问题，而且这个问题不应该试图捕获 —意味着在程序中，错误一旦出现不能处理 —
VirtualMachineError : StackOverflowError, OutOfMemoryError - Exception — 表示合理的应用程序想要捕获的问题，也因此可以处理。处理方式：要么捕获要么抛出
- 编译时异常：在编译时期就已经出现，要求必须处理。
- CloneNotSupportedException UnsupportedEncodingException ParseException
- 运行时异常：在编译时期不出现到运行的时候才出现。可以处理可以不处理 — RuntimeException
ArithmeticException ArrayIndexOutOfBoundsException
NullPointerException ClassCastException
StringIndexOutOfBoundsException NumberFormatException - 自定义异常：写一个类继承Exception或者是其子类。如果是继承了RuntimeException及其子类，那么这个时候定义的是一个运行时异常；如果继承的是其他的Exception，那么定义的就是编译时异常
- 异常的捕获方式
A. 如果多个异常的处理方式各不一样，可以使用多个catch分别捕获分别处理
B. 如果所有异常的处理方式都一样，可以捕获这些异常的父类进行统一的处理
C. 如果多个异常进行了分组，那么同一组的异常之间用 | 隔开进行分组处理 — 从JDK1.7开始
package cn.tedu.exception;
public class ExceptionDemo6 {
public static void main(String[] args) {
System.out.println(m());
}
public static int m() {
int i = 4;
// 方法在栈内存中执行
// 方法在执行过程中的计算和存储是分成了2块
// 在代码执行过程中，会出现计算和存储分别进行的现象
// 代码是从上到下来依次编译运行的
try {
// 先运行return i++;
// 在计算区域将i的值从存储区域取出来进行计算
// 在计算的时候由于++在后，所以将i的值4作为数据参与下一步运算
// 下一步运算 return 4;
// 在执行return 4准备返回的时候需要检查是否有后续操作执行：i的自增，finally
// 先让i进行自增为5
// 然后继续执行下一个后续操作是finally
// 后续操作全部完成最后在执行刚才被挂起的return 4;
return i++;
} finally {
// 在finally中对i再次自增为6
i++;
System.out.println("finally:" + i);
}
}
}
public static Person m() {
Person p = new Person();
try {
p.setName("如花");
p.setAge(80);
// p是对象，所以return的是p的地址
return p;
} finally {
p.setName("周星星");
p.setAge(18);
}
}
package cn.tedu.exception;
public class ExceptionDemo2 {
public static void main(String[] args) /* throws FileNotExistException */ {
try {
String msg = readTxt("E:\\a.jpg");
System.out.println(msg);
} catch (FileNotExistException e) {
System.out.println(e.getMessage());
System.out.println("在处理这个问题~~~");
} catch (FileFormatException e) {
System.out.println(e.getMessage());
} catch (NullPointerException e) {
System.out.println("处理空指针~~~");
}
// try {
// String msg = readTxt("E:\\a.jpg");
// System.out.println(msg);
// } catch (Exception e) {
// System.out.println(e.getMessage());
// }
// 一定是先子类异常后父类异常
try {
String msg = readTxt("E:\\a.jpg");
System.out.println(msg);
} catch (FileNotExistException | FileFormatException e) {
// System.out.println(e.getMessage());
// 打印栈轨迹
e.printStackTrace();
} catch (NullPointerException e) {
System.out.println("处理空指针~~~");
} catch (Exception e) {
}
System.out.println("running~~~");
}
public static String readTxt(String path) throws FileNotExistException, FileFormatException, NullPointerException {
if (path == null)
throw new NullPointerException("亲，路径不能并且空~~~");
// 可能路径不存在
if (path.startsWith("H:\\"))
throw new FileNotExistException("亲，这个文件不存在哦~~~");
// 文件格式不一样
if (!path.endsWith(".txt"))
throw new FileFormatException("亲，需要一个TXT文件~~~");
return "读取成功~~~";
}
}
@SuppressWarnings("serial")
class FileFormatException extends Exception {
public FileFormatException() {
}
public FileFormatException(String msg) {
super(msg);
}
}
@SuppressWarnings("serial")
class FileNotExistException extends Exception {
private String msg;
public FileNotExistException() {
}
public FileNotExistException(String msg) {
this.msg = msg;
}
public String getMessage() {
return msg;
}
}
public static void main(String[] args) throws CloneNotSupportedException, ParseException {
// try {
// System.out.println(1 / 0);
// } catch (ArithmeticException e) {
// System.out.println("在处理这个算术异常~~~");
// }
// int[] arr = new int[3];
// System.out.println(arr[5]);
// String str = null;
// System.out.println(str.length());
// Object o = new Object();
// String str = (String) o;
// Integer in = new Integer("abc");
// new ExceptionDemo().clone();
// "abc".getBytes("abc");
// new SimpleDateFormat("yyyy-MM-dd").parse("2012-03-05");
}
集合
- 集合是一个存储多个同一类型的数据的容器 — 大小是不固定的
- - 泛型，表示集合中的元素的数据类型
- List - 列表
保证元素的存入顺序，列表中的元素是可以重复的。可以通过下标操作指定位置上的元素
ArrayList - 顺序表
底层是基于数组来存储数据。内存空间是连续的。默认初始容量是10，每次扩容默认增加一半，基于了右移。增删操作相对复杂，查询操作相对简单。是一个线程不安全的列表。
LinkedList - 链表
基于节点(Node)来实现的。利用节点来存储数据以及维系链表之间每一个节点的关系。内存空间不连续。增删操作相对简单，查询操作相对复杂。是一个线程不安全的列表
LinkedList：基于节点，内存空间是不连续的。相对增删简单但是查询复杂。是一个线程不安全的列表
考虑：如果在增删和查询的次数相差不多的情况下，使用ArrayList还是LinkedList？ — LinkedList
因为ArrayList要保证一段连续的存储空间，而LinkedList不用，节点都是散开分布的，所以存储性能好。
LinkedList的增删是基于二分查询的，跟中间比较，小的话从头开始查找、大的话从尾开始查找。
- Vector - 向量
最早的列表，依靠数组来存储数据，内存空间一定是连续的,初始默认是10，每次扩容默认增加一倍。是一个线程安全的列表 - Stack - 栈
继承了Vector。遵循后进先出/先进后出的原则。最先放入栈中的元素 — 栈底元素，最后放入栈中的元素 — 栈顶元素。将元素放入栈中 — 入栈/压栈，将元素从栈中取出 — 出栈/弹栈 - Set - 散列集合
包含的元素不重复，保证元素的唯一性
HashSet：散列集合，不包含重复的元素，不保证元素的存入顺序。底层基于HashMap来进行数据的存储。 -> 基于了数组+链表结构（链表栈结构）。默认初始容量是16，默认加载因子是0.75f，默认增加一倍。
TreeSet：要求存入的元素对应的类必须实现Comparable的接口，然后利用接口中compareTo方法进行自然排序；如果需要对某一个TreeSet单独指定排序规则，则需要传入一个Comparator对象
- 加载因子过小，会导致频繁发生rehash操作而降低效率，同时还造成空间资源的浪费
加载因子过大，会导致每一个桶中的链的长度过长，从而降低增删效率。
从JDK1.8开始，对HashSet的存储做了调优：如果桶中的链的长度大于了8，会将这个链式结构扭转成一个二叉树结构 - TreeSet — 会对元素进行整体的自然排序，需要元素对应的类实现Comparable接口
Comparable —类在实现这个接口之后对这个类的所有的对象进行整体排序
Comparator — 用于给某个对象单独指定规则
总结：如果需要给某个TreeSet对象单独指定比较规则，则使用Comparator；如果不指定比较规则，则使用Comparable进行整体的自然排序 - Collections - 操作集合的工具类
package cn.tedu.collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args) {
// 集合中存储的元素类型是String
Collection<String> c = new ArrayList<String>();
// 添加元素
c.add("gwe");
c.add("hred");
c.add("hrd");
c.add("ater");
// 将集合转化为数组
// Object[] os = c.toArray();
// String[] os = (String[]) c.toArray();
// for (Object o : os) {
// System.out.println(((String) o).length());
// }
// String[] strs = c.toArray(new String[0]);
// for (String str : strs) {
// System.out.println(str.length());
// }
// 获取集合中的元素个数
// System.out.println(c.size());
// 清空集合
// c.clear();
// 判断集合是否为空
// System.out.println(c.isEmpty());
// 判断元素是否存在
// System.out.println(c.contains("hrd"));
// System.out.println(c.contains("aft"));
// 从集合中移除指定的元素
// c.remove("gwe");
// 如果元素不存在，会直接跳过
// c.remove("age");
// System.out.println(c);
}
}
package cn.tedu.collection;
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
// 保证元素的存入顺序
list.add("bdd");
list.add("abd");
list.add("egd");
list.add("eds");
list.add("abd");
list.add(null);
// 截取子列表
System.out.println(list.subList(1, 3));
// 获取指定的元素在列表中第一次出现的位置
// System.out.println(list.indexOf("abd"));
// List<String> list2 = new ArrayList<String>();
// list2.add(new String("bdd"));
// list2.add("abd");
// list2.add("egd");
// list2.add("eds");
// 比较两个列表的时候是逐位比较是否一致
// System.out.println(list.equals(list2));
// for(int i = 0; i < list.size(); i++)
// System.out.println(list.get(i));
// 获取指定下标上的元素
// System.out.println(list.get(1));
// 向列表的指定的下标插入指定的元素
// list.add(1,"fec");
// list.add(4, "fec");
// list.add(6, "fec");
// 移除指定下标上的元素
// list.remove(0);
// list.remove(5);
// 替换指定位置上的元素
// list.remove(2);
// list.add(2, "abc");
// list.set(2, "abc");
System.out.println(list);
}
}
右移一位和除二的区别
https://blog.youkuaiyun.com/FlushHip/article/details/82495034
手写ArrayList
package cn.tedu.collection;
import java.util.Arrays;
public class ListExer {
public static void main(String[] args) {
ArrList list = new ArrList(1);
list.add("abc");
list.add("abc");
list.add("def");
// list.add(0, "hijk");
list.remove(0);
System.out.println(list);
}
}
class ArrList {
private String[] data;
// 记录元素的个数
private int size = 0;
public ArrList() {
data = new String[10];
}
public ArrList(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
data = new String[initialCapacity];
}
// 添加元素
public void add(String str) {
// 判断是否需要扩容
if (size >= data.length)
this.grow();
data[size++] = str;
}
// 扩容
private void grow() {
if (data.length <= 1)
data = Arrays.copyOf(data, data.length + 1);
else
data = Arrays.copyOf(data, data.length + (data.length >> 1));
}
// 插入元素
public void add(int index, String str) {
// 判断下标越界
if (index > size)
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
// 判断扩容
if (size >= data.length)
this.grow();
// 挪动元素空出对应的位置
// for (int i = size - 1; i >= index; i--) {
// data[i + 1] = data[i];
// }
System.arraycopy(data, index, data, index + 1, size - index);
// // 插入元素
data[index] = str;
size++;
}
private void out(int index) {
// 判断下标越界
if (index >= size)
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
// 根据下标移除指定的元素
public void remove(int index) {
this.out(index);
// for(int i = index; i < size - 1; i++){
// data[i] = data[i + 1];
// }
System.arraycopy(data, index + 1, data, index, size - (index + 1));
size--;
}
// 移除指定的元素
public void remove(String str) {
// 首先先找到这个元素出现的位置
int index = indexOf(str);
if (index != -1)
this.remove(index);
}
// 找这个元素第一次出现的位置
public int indexOf(String str) {
for (int i = 0; i < size; i++) {
if (data[i] == str || data[i] != null && data[i].equals(str))
return i;
}
return -1;
}
public void clear() {
data = new String[10];
size = 0;
}
public boolean contains(String str) {
return indexOf(str) != -1;
}
public String get(int index) {
this.out(index);
return data[index];
}
public boolean isEmpty() {
return size == 0;
}
public void set(int index, String str) {
this.out(index);
data[index] = str;
}
public int size() {
return size;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < size; i++) {
sb.append(data[i]).append(", ");
}
String str = sb.toString();
if (size > 0)
str = str.substring(0, str.length() - 2);
return str += "]";
}
}
手写LinkedList
目录,再往上一拉
package cn.tedu.collection;
public class ListExer2 {
public static void main(String[] args) {
LinkList list = new LinkList();
list.add("a");
list.add("b");
list.add("c");
// list.add(0,"d");
// list.add(1, "e");
// list.remove(0);
// list.remove(2);
list.remove(1);
System.out.println(list);
}
}
class LinkList {
private int size = 0; // 节点个数
private Node first; // 第一个节点
private Node last; // 最后一个节点
public LinkList() {
}
public void add(String str) {
// 创建节点存储数据
Node node = new Node(null, str, null);
// 列表此时为空
if (size == 0) {
// 如果列表为空，则头结点指向新节点
this.first = node;
} else {
// 原来的尾节点的下一位置为新节点
this.last.next = node;
// 新节点的上一位是原来的尾节点
= this.last;
}
// 新的节点变成了尾节点
this.last = node;
size++;
}
public void add(int index, String str) {
// 判断下标是否越界
if (index > size)
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
// 在尾部追加
if (index == size) {
this.add(str);
return;
}
Node node = new Node(null, str, null);
// 插入的头部
if (index == 0) {
node.next = this.first;
this.first.prev = node;
this.first = node;
} else {
Node no = this.getNode(index);
// 原节点的上一个节点的下一位变成新的节点
no.prev.next = node;
// 新的节点的上一位是原节点的上一位
node.prev = no.prev;
// 新节点的下一位是原来的节点
node.next = no;
// 原节点的上一位是新的节点
no.prev = node;
}
size++;
}
private Node getNode(int index) {
// 获取指定位置的节点
Node no = this.first;
for (int i = 0; i < index; i++) {
no = no.next;
}
return no;
}
private void out(int index) {
// 判断下标越界
if (index >= size)
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
public void remove(int index) {
this.out(index);
// 头部
if (index == 0) {
this.first = this.first.next;
this.first.prev = null;
} /* 尾部 */ else if (index == size - 1) {
this.last = this.last.prev;
this.last.next = null;
} else {
Node node = this.getNode(index);
// 原节点的上一个节点的下一位变成原节点的下一位
node.prev.next = node.next;
// 原节点的下一个节点的上一位变成原节点的上一位
node.next.prev = node.prev;
}
size--;
}
public int indexOf(String str) {
Node node = this.first;
for (int i = 0; i < size; i++) {
String data = node.data;
if (data == str || data != null && data.equals(str))
return i;
node = node.next;
}
return -1;
}
public String toString() {
StringBuilder sb = new StringBuilder("[");
Node node = this.first;
for (int i = 0; i < size; i++) {
sb.append(node.data).append(", ");
node = node.next;
}
String str = sb.toString();
if (size > 0)
str = str.substring(0, str.length() - 2);
return str += "]";
}
// 利用节点存储数据
private class Node {
Node prev; // 上一个节点
String data; // 元素
Node next; // 下一个节点
public Node(Node prev, String data, Node next) {
super();
this.prev = prev;
this.data = data;
this.next = next;
}
}
}
set集合排序
package cn.tedu.collection;
import java.util.Comparator;
import java.util.TreeSet;
public class SetDemo2 {
public static void main(String[] args) {
// TreeSet<String> set = new TreeSet<String>();
// 会根据自然顺序（往往是升序）进行排序
// set.add("d");
// set.add("g");
// set.add("a");
// set.add("r");
// set.add("c");
// System.out.println(set);
TreeSet<Student> set = new TreeSet<Student>();
// 按照分数进行降序排序
// TreeSet<Student> set = new TreeSet<Student>(new Comparator<Student>()
// {
//
// @Override
// public int compare(Student o1, Student o2) {
// return o2.getScore() - o1.getScore();
// }
// });
// 要求set中的元素所对应的类必须实现Comparable
set.add(new Student("01金毛狮王", 20, 59));
set.add(new Student("03白眉鹰王", 50, 18));
set.add(new Student("02紫衫龙王", 49, 89));
set.add(new Student("05青翼蝠王", 38, 60));
for (Student s : set) {
System.out.println(s);
}
}
}
class Student implements Comparable<Student> {
private String name;
private int age;
private int score;
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
}
@Override
// 排序规则就写在compareTo中
// 在排序的时候会根据返回值的正负来确定元素的排序顺序
// 如果返回了一个正数，那么this就会排在o之后
// 如果返回了一个负数，那么this就会排在o之前
public int compareTo(Student o) {
// return this.age - o.age; //升序
// return o.age - this.age; //降序
return name.compareTo(o.name);
}
}
Stack - 栈集合
目录,再往上一拉
Stack<String> s = new Stack<String>();
// 添加元素
s.push("d");
s.push("a");
s.push("e");
s.push("s");
s.push("h");
// 从栈顶到栈底依次查找，以1基数
System.out.println(s.search("a"));
// 判断栈是否为空
// System.out.println(s.empty());
// 查看栈顶元素
// 如果栈为空，则抛出空栈异常
// System.out.println(s.peek());
// 移除栈顶元素
// System.out.println(s.pop());
System.out.println(s);
练习：使用数组/节点(Node)完成一个Stack — empty peek pop push search
目录,再往上一拉
package cn.tedu.collection;
import java.util.Arrays;
import java.util.EmptyStackException;
public class StackExer {
public static void main(String[] args) {
// ArrStack as = new ArrStack();
// as.push("a");
// as.push("b");
// as.push("c");
// as.pop();
LinkStack ls = new LinkStack();
ls.push("a");
ls.push("b");
ls.push("c");
System.out.println(ls);
}
}
class LinkStack {
private int size = 0;
private Node first;
public boolean empty() {
return size == 0;
}
public void push(String str) {
Node node = new Node(null, str);
// if (size != 0) {
// node.next = this.first;
// }
this.first = node;
size++;
}
public String peek() {
if (size == 0)
throw new EmptyStackException();
return this.first.data;
}
public String pop() {
String str = this.peek();
this.first = this.first.next;
size--;
return str;
}
public int search(String str) {
Node node = this.first;
for (int i = 0; i < size; i++) {
if (node.data == str || str != null && str.equals(node.data))
return i + 1;
node = node.next;
}
return -1;
}
@Override
public String toString() {
return "LinkStack [size=" + size + ", first=" + first + "]";
}
private class Node {
Node next;
String data;
public Node(Node next, String data) {
super();
this.next = next;
this.data = data;
}
}
}
class ArrStack {
private String[] data = new String[10];
private int size = 0;
public String peek() {
// 判断栈中是否有元素
if (size == 0)
throw new EmptyStackException();
return data[size - 1];
}
public String pop() {
String str = this.peek();
size--;
return str;
}
public void push(String str) {
// 判断是否需要扩容
if (size >= data.length)
data = Arrays.copyOf(data, data.length * 2);
data[size++] = str;
}
public int search(String str) {
// for(int i = size - 1, j = 1; i >= 0; i--, j++){
//
// if(str == data[i] || str != null && str.equals(data[i]))
// return j;
//
// }
for (int i = size - 1; i >= 0; i--) {
if (str == data[i] || str != null && str.equals(data[i]))
return size - i;
}
return -1;
}
}
JDK8 新特性
目录,再往上一拉
package exer1;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class StreamDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abe");
list.add("egs");
list.add("dgse");
list.add("3sdf");
list.add("sdh8");
list.add("dbks");
list.add("vn3hdso");
// 流式结构，但不是流，可以批量的操作集合中的数据
// JDK1.8的新特性之一
Stream<String> stream = list.stream();
System.out.println(stream.allMatch(str -> str.matches(".*\\d.*")));
// 判断集合中是否包含以字母a开头的字符串
System.out.println(stream.anyMatch(str -> str.startsWith("a")));
stream.filter(new Predicate<String>() {
@Override
public boolean test(String t) {
return t.matches(".*\\d.*");
}
}).forEach(new Consumer<String>() {
@Override
public void accept(String t) {
System.out.println(t);
}
});
stream.filter(str -> str.matches(".*\\d.*"))
.map(str -> str.replaceAll("\\d", ""))
.forEach(str -> System.out.println(str));
// for (String str : list) {
// if (str.matches(".*\\d.*")) {
// str = str.replaceAll("\\d", "");
// System.out.println(str);
// }
// }
}
}
Vector
目录,再往上一拉
package cn.tedu.collection;
import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
// Vector<String> v = new Vector<String>();
// 表示向量的初始容量是10，每次扩容增加5个
// Vector<String> v = new Vector<String>(10, 5);
// System.out.println(v.capacity());
//
// for (int i = 0; i < 21; i++) {
// v.add("a");
// }
//
// System.out.println(v.capacity());
Vector<String> v = new Vector<String>();
v.add("a");
v.add("d");
v.add("t");
v.add("h");
// 获取迭代器
Enumeration<String> e = v.elements();
// 判断后续是否还有元素
while (e.hasMoreElements()) {
// 挪动指针获取这一个元素
String str = e.nextElement();
System.out.println(str);
// 无法清空集合
// v.remove(str);
}
System.out.println(v);
}
}
迭代器
- 迭代器是通过指针的挪动来依次获取集合中的每一个元素。
- Enumeration - 最早期的迭代器
- Iterator -通过迭代器自带的remove方法来移除当前在迭代的元素， it.remove();
实质是：一个集合实现迭代器后(产生一个迭代器对象），迭代器会复制一份集合，然后对这份集合中每一个元素进行标记（true/false），然后去和原集合对比，确定每一个元素是否该删除。因此在迭代过程中不允许直接增删原集合，否则会产生ConcurrentModificationException 当前认证（标记）异常。 - Collection中的iterator方法是从Iterable中继承过来的，实现了Iterable接口的类产生的对象可以被增强for循环进行遍历。 — 增强for循环也是JDK1.5的特性之一。增强for循环本质上是一个迭代遍历，简化了迭代操作！
- 迭代器：Iterator - 通过状态标记和指针的挪动来遍历元素 - 在迭代过程中不允许直接增删原集合。Iterable接口提供了获取迭代器的方法，实现了这个接口的类所产生的对象可以被增强for循环遍历
List<String> list = new ArrayList<String>();
list.add("abe");
list.add("egs");
list.add("dgse");
list.add("dase");
list.add("3sdf");
list.add("sdh8");
list.add("dbks");
list.add("vn3hdso");
// 通过iterator方法获取到一个Iterator对象
Iterator<String> it = list.iterator();
// 判断是否有下一个元素
while(it.hasNext()){
// 挪动指针获取这个元素
String str = it.next();
System.out.println(str);
// 通过迭代器自带的remove方法来移除当前在迭代的元素
// it.remove();
list.remove(str);
}
System.out.println(list);
泛型
参数化类型 - ParameterizedType — JDK1.5的特性之一
用具体类型来替代泛型的过程 — 泛型的擦除 — 编译期
? extends 类/接口 表示传入这个类/接口或者是其子类/子接口对象 — 上限
? super 类/接口 表示传入这个类/接口及其父类/父接口的对象 — 下限
? 表示泛型的通配符
package cn.tedu.type;
import java.util.ArrayList;
//import java.util.Iterator;
import java.util.List;
public class TypeDemo1 {
public static void main(String[] args) {
// 在早期没有泛型的限制的时候，集合中存储元素是Object类型
// List list = new ArrayList();
// List<String> list = new ArrayList();
// List list = new ArrayList<String>();
// List<String> list = new ArrayList<String>();
// 从JDK1.7开始，后边实现类的泛型可以省略不写
// 会根据程序的上文来进行类型的自动推导
List<String> list = new ArrayList<>();
list.add("a");
// list.add(5);
// list.add(3.5);
// list.add(new Object());
// Iterator it = list.iterator();
// while (it.hasNext()) {
// Object o = it.next();
//
// if (o instanceof String) {
// String str = (String) o;
// } else if (o instanceof Integer) {
// Integer in = (Integer) o;
// }
// }
}
// public static void m(List list){}
}
package cn.tedu.type;
public class TypeDemo2 {
public static void main(String[] args) {
Demo<String, Integer> demo = new Demo<>();
demo.set("abc");
System.out.println(demo.get());
}
}
// <T> 表示定义了一个泛型叫T
// 泛型的命名只要符合标识符的命名规则即可
// 习惯上泛型一般只使用一个大写字母进行命名
// T type
// E element
// K key
// V value
// R result/return
class Demo<T, E> {
// 泛型定义的变量不能直接实例化
private T t;
E e;
public void set(T t) {
this.t = t;
}
public T get() {
return t;
}
}
package cn.tedu.type;
public class TypeDemo3 {
public static void main(String[] args) {
A a = new A();
a.m(5);
a.m(true);
a.m("def");
}
}
class A {
// 表示给当前的方法定义了一个单独的泛型
public <T> void m(T t) {
System.out.println(t.getClass());
}
}
package cn.tedu.type;
import java.util.ArrayList;
import java.util.List;
public class TypeDemo4 {
public static void main(String[] args) {
List<Integer> ins = new ArrayList<>();
ins.add(3);
ins.add(4);
ins.add(6);
ins.add(7);
ins.add(0);
List<Double> dos = new ArrayList<>();
dos.add(3.6);
dos.add(4.2);
dos.add(6.8);
dos.add(7.7);
dos.add(0.2);
// 泛型不存在向下兼容
print(ins);
print(dos);
// List<String> strs = new ArrayList<>();
// print(strs);
}
// 写一个新的方法来遍历元素类型是数字的列表
// 元素类型是Number或者是其子类
// ? extends 类/接口 表示传入这个类/接口或者是其子类/子接口对象
// 所能传入的元素的最大类型限定为Number
// 规定了泛型的上限
public static void print(List<? extends Number> list) {
// 不能再添加任何元素除非是null
list.add(null);
for (Number n : list) {
System.out.println(n);
}
}
// 泛型的下限
// 传入元素类型是String及其父类的列表
// ? super 类/接口 表示传入这个类/接口及其父类/父接口的对象
// 表示传入的最小类型是String
public static void m(List<? super String> list){
list.add("abc");
for (Object o : list) {
System.out.println(o);
}
}
}
package cn.tedu.type;
import java.util.ArrayList;
import java.util.List;
public class TypeDemo5 {
public static void main(String[] args) {
List<Integer> ins = new ArrayList<>();
ins.add(7);
ins.add(3);
ins.add(6);
ins.add(0);
ins.add(4);
sort(ins);
}
// 可以接收任意类型，但是在排序（操作）期间不允许发生增删操作
public static void sort(List<?> list){
list.add(null);
}
}
Map<K, V> - 映射
- 映射：用于存储键值对的容器。每一个键对应一个值，键是唯一的。
- 一个键对应一个值。键是唯一的，值可以重复。
- 每一个键和它所对应的值构成了键值对。— 一个Map是由多个键值对来组成。
- 将每一个键值对看作一个对象，抽取出来一个代表键值对的接口
- Entry，内部会有一个内部类实现这个Entry接口。Entry是Map中的内部接口 — 一个Map是由多个Entry对象来组成的
- Map不是集合，但是Map是Java集合框架的成员。
Java集合框架(Java Collections Framework)包含：集合、数组、映射以及操作它们的工具类 — Arrays、Collections、Interator、Comparable、Comparator - 遍历映射
方式一：先获取映射中所有的键组成的集合，然后通过键获取对应的值
方式二：将所有的键值对放入集合中，然后遍历集合获取这个键值对的数据 - HashMap：基于哈希码存储，然后允许键和值为null。默认初始容量是16，默认加载因子是0.75f，每次默认增加一倍。自定义初始容量x，这个x介于[2n,2n+1],那么初始容量一定是2n+1 — 底层保证HashMap的容量永远是2n的形式。本身是一个异步式线程不安全的映射
- Hashtable：基于哈希码存储，然后不允许键和值为null。默认初始容量是11，默认加载因子是0.75f，每次默认增加一倍，然后再+1 — 11 -> 23。本身是一个同步式线程安全的映射。 ConcurrentHashMap — 异步式线程安全的映射
Map<String, Integer> map = new HashMap<>();
// 添加元素
map.put("d", 4);
map.put("h", 7);
map.put("z", 7);
map.put("o", 3);
map.put("t", 3);
// 如果键相同则对应的值覆盖
map.put("o", 0);
map.put("e", null);
// 获取键值对的个数
System.out.println(map.size());
// 移除键值对
// map.remove("o");
// 判断键是否存在
// System.out.println(map.containsKey("f"));
// 判断值是否存在
// System.out.println(map.containsValue(4));
// 根据指定的键获取对应的值
// System.out.println(map.get("o"));
// 如果键不存在则返回null
// System.out.println(map.get("y"));Map<String, Integer> map = new HashMap<>();
map.put("d", 4);
map.put("h", 7);
map.put("z", 7);
map.put("o", 3);
map.put("t", 3);
// 遍历映射
// 方式一：先获取映射中所有的键组成的集合，然后通过键获取对应的值
// keySet表示将映射中的所有的键放入一个Set集合中
// Set<String> set = map.keySet();
// for (String key : set) {
// System.out.println(key + "=" + map.get(key));
// }
// 方式二：将所有的键值对放入集合中，然后遍历集合获取这个键值对的数据
// entrySet表示将映射中的所有的键值对放入一个Set集合中
Set<Map.Entry<String, Integer>> set = map.entrySet();
// 遍历集合，然后从键值对中获取键和值
for (Map.Entry<String, Integer> entry : set) {
System.out.println(entry.getKey() + "=" + entry.getValue());
}
System.out.println(map);
输入一个字符串，统计其中每一个字符出现的次数
目录,再往上一拉
package cn.tedu.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
/**
* 输入一个字符串，统计其中每一个字符出现的次数
*/
public class MapExer {
@SuppressWarnings("resource")
public static void main(String[] args) {
// 获取字符串
Scanner s = new Scanner(System.in);
String str = s.next();
// 定义一个映射，键存储字符，值存储个数
Map<Character, Integer> map = new HashMap<>();
// 遍历字符串，然后统计每一个字符出现的次数
for (int i = 0; i < str.length(); i++) {
// 获取对应位置的字符
char c = str.charAt(i);
// 判断这个字符在映射是否出现过
if (map.containsKey(c))
map.put(c, map.get(c) + 1);
else
map.put(c, 1);
}
// 遍历映射
for (Map.Entry<Character, Integer> entry : map.entrySet())
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
断言
- 对结果进行预测。
- assert 断言条件 ： 错误信息;
- 在Java中，断言不是默认开启的，需要利用参数手动指定开启 -> -ea -> -enableassertion
Scanner s = new Scanner(System.in);
int age = s.nextInt();
// 进行断言
// 如果断言成功，则继续往下执行
// 如果断言失败，则抛出错误AssertionError
assert age > 0 : "预测年龄应该是大于0的数值，实际上是" + age;
System.out.println(age);
Scanner s = new Scanner(System.in);
int age = s.nextInt();
// 进行断言
// 如果断言成功，则继续往下执行
// 如果断言失败，则抛出错误AssertionError
assert age > 0;
System.out.println(age);
扩展：native修饰方法— 本地方法，没有方法体但不是抽象方法，方法体是在JVM中用C语言完成的，在本地方法栈中执行
目录,再往上一拉
Scanner s = new Scanner(System.in);
// 用空白字符进行分隔
int i = s.nextInt();
double d = s.nextDouble();
String str = s.next();
// 用回车换行进行分隔
// 以上次结束作为本次的开始
String str2 = s.nextLine();
// System.out.println(i);
// System.out.println(d);
// System.out.println(str);
System.out.println(str2.equals(""));
扫一扫
1217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
