千峰教育2218期2202.11.11

[TOC]

复习

String 字符串
	字符串是一个常量，调用和执行过程中，数据不可修改，并且 Java 中规定， 英文双引号包含的字符串内容，内容一致，
	在整个程序运行过程中，当前字符串常量有且只有一个。
	
	【要求】
		字符串内容不允许使用 == ，有且只能使用 equals
		字符串方法：
			获取
				int length();
				char charAt(int index);
				int indexOf(int ch);
				int lastIndexOf(int ch);
				int indexOf(String str);
				int lastIndexOf(String str);
				String substring(int begin);
				String substring(int begin,i nt end);
			判断
				boolean endsWith(String str);
				boolean startsWith(String str);
				booleam isEmpty();
				boolean contains(String str);
				boolean equals(Object obj);//Override equals in Type Object;
				boolean equalsIgnoreCase(String str);
			
			
			转换
				String(char[] arr);
				String(char[] arr, int offset, int length);
				public static String valueOf(char[] arr);
				public static String valueOf(char[] arr, int offser, int length);
				char[] toCharArray();
			
			其他
				String replace(char oldChar, char newChar);
				String[] split(String str);
				String toUpperCase();
				String toLowerCase();
				String trim();
			

集合
	为什么要用集合，主要解决的是数据的能力问题
	数组弊端
		1. 容量受限，数组一旦确定容量不能修改
		2. 数组类型支持单一，一旦明确支持的数据类型，无法修改
		3. 配套方法少，复用价值低
		4. 因数据类型单一，配套方法无法复用其他类型
	集合解决的问题
		1. 容量问题不需要程序员考虑，集合自行处理
		2. 集合支持数据类型多样化，同时在约束之后，满足数据类型一致化要求
		3. 集合配套方法，工具类，特殊操作众多
		4. 类型支持多样，方法支持复用，效率高
		
	interface  Collection
	--| interface List 有序，可重复
	----| class ArrayList<E>  可变长数组结构
	----| class LinkedList<E> 双项链表结构
	----| class Vector<E> 线程安全的，效率较低的，可变长数组结构
	
	--|interface Set 无序，不可重复
	----| class HashSet<E> 底层为哈希表结构
	----| class TreeSet<E> 底层为二叉树结构
	
	Collection 常用方法
	增
		add(E e);
		addAll(Collection<? extends E> c);
	删
		remove(Object obj);
		removeAll(Collection<?> c);
		retainAll(Collection<?> c);
		clear();
	查
		int size();
		boolean isEmpty();
		boolean contains(Object obj);
		boolean contains(Collection<?> c);
		Object[] toArray();

	List 集合
		有序 添加顺序和数据存储顺序一致，默认采用【尾插法】
		可重复 List 集合运行出现相同元素
		List 集合相较于 Collection 集合最大的特征就是引入的【下标操作】
		
		增
			add(E e);
			addAll(Collection<? extends E> c);
			add(int index, E e);
			addAll(int index, Collection<? extneds E> c);
		删
			E remove(int index);
			remove(Object obj);
			removeAll(Collection<?> c);
			retainAl(Collecttion<?> c);
			clear();
		改
			E set(int index, E e);
		查
			int size();
			boolean isEmpty();
			boolean contains(Object obj);
			boolean containsAll(Collection<?> c);
			Object[] toArray();
			E get(int index);
			List<E> subList(int fromIndex, int toIndex);
		int indexOf(Object obj);
		int lastIndexOf(Obejct obj);
		

List集合对比和Set集合

1. List 集合

1.1 List 集合概述

List 集合特征：
	1. 有序
	2. 可重复
	3. 存在下标相关操作
	
	
List 集合实现类：
	ArrayList
	 	底层是可变长数组结构 特征：增删慢，查询快
	LinkedList
		底层是双向链表结构   特征： 增删快，查询慢
	Vertor
		线程安全，性能较低的，可变长数据结构
	

1.2 ArrayList 可变长数组结构

1.21 ArrayList 概述

	底层是一个可变长数组结构，数组数据类型是 Object 类型，可以存储任意类型元素，同时所有可以给予当前数组进行数据添加操作的方法(add, addAll, set)限制泛型类型，同时集合中所有可以获取底层数组元素的方法也引入泛型约束(get, subList),保证集合存储数据类型一致化和集合数据获取类型一致化。
	底层数组扩容操作由 ArrayList 自行完成，扩容的流程：
		1. 方法参数为最小容量需求 minCapacity = size + 添加元素个数；
		2. 获取数据数组容量 oldCapacity
		3.计算得到新数组容量
			newCapacity = oldCapacity + oldCapacity / 2
			newCapacity = oldCapacity + (oldCapacity >> 1)
			数据右移一位(oldCapacity >> 1) <==> oldCapacity / 2
		4. 判断新数组容量是否满足最小容量需求
		5. 判断新数组容量是否超出 MAX_ARRAY_SIZE
		6. 创建新数组
		7. 从原数组中移动数组到新数组
		8.存储新数组地址
		
	ArrayList 集合因为底层结构为数组结构，所以性能上：增删慢，查询快
	

1.22 ArrayList 增删慢

增加慢：
	1.增加操作有可能会导致数组容量扩容，扩容操作中，数据从原数组移动到新数组中【时间效率低】
	【空间效率低】因为在扩容操作过程中，方法运行所需内存空间是原数组的 2.5 左右【1 + 1.5】，数据空间占用比较高，同时在执行数据复制移动操作之后，原数组数据空间需要收回
	2. 在指定下标位置添加元素，只要不是采用【尾插法】，从添加数据位置开始，之后元素需要整体向后移动，移动过程中【时间效率低】

删除慢：
	1. 指定元素删除操作，除末尾元素删除，其他任意一个位置元素删除之后，从删除位置开始所有数组元素整体向前移动。移动过程非常浪费时间【时间效率低】
	2. 删除操作.有可能会导致有效数据和数组底层容量比例失衡，以及空置的元素空间个数超过【阈值】
	3. 一旦触发缩容操作，同时会导致
		【时间效率低】 数据需要移动
		【空间效率低】 在缩容过程中，方法执行过程中空间占用较大，包括对于原数组空间释放需要时间

1.23 ArrayList 查询快

	ArrayList 底层是一个 Object 类型，同时有下标操作的的方式，可以根据数组首地址 + 下标 快速计算对应元素所在的内存地址，CPU 快速访问，效率极高
	ArrayList 查询快。

分析结构的特征主要为了选择更为合适合理的结构，处理存储对应数据。

1.3 LinkedList 双向链表结构

带有链表头的双向链表结构，整个链表结构有两个数据类型
	1. 链表头 	LinkedList<E>
    2. 结点    Node<E>
    

1.32 LinkedList 特征方法

addFirst(E e);
	在链表头添加符合实例化过程泛型约束元素
addLast(E e);
	在链表尾添加符合实例化过程泛型约束元素
E getFirst();
	获取链表头结点存储元素
E getLast();
	获取链表尾结点存储元素
E removeFrist();
	删除链表头结点，返回值是删除的元素
E removeLast();
	删除链表尾结点，返回值是删除的元素

package com.qfedu.a_list;

import java.util.LinkedList;

public class Demo1 {
	public static void main(String[] args) {
		LinkedList<String> list = new  LinkedList<String>();
		
		list.add("风花雪月");
		list.add("风花雪月");
		list.add("风花雪月");
		list.add("风花雪月");
		list.add("风花雪月");
		
		System.out.println(list);
		
		list.addFirst("沉鱼落雁");
		list.addLast("阴晴圆缺");
		System.out.println(list);
		
		System.out.println(list.getFirst());
		System.out.println(list.getLast());
		
		System.out.println(list.removeFirst());
		System.out.println(list.removeLast());
		
		System.out.println(list);
		
		
	}
}