java基础11【异常、集合、迭代器、泛型、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.csdn.net/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(""));