Java知识点（零散5）

类和接口总览：

Collection：用来存储管理一组对象 objects，这些对象被称为元素 elements
	Set：元素不能重复
		Sort额度Set：一组有序的不能重复的元素
	List：线性结构
	Queue：队列
	Deque：双端队列
Map：键值对 key-Value-pair
	SortedMap：一组有序的键值对		

数组 和 集合的区别：

数组：长度固定，可以存储基本数据类型，也能存储对象
集合：长度可变，只能存储对象类型（由于有包装类存在，集合可以存储任何类型）
     集合提供了丰富的 API，

集合体系：

集合也叫容器，用于存储对象。
根据不同的需求 和 不同的数据结构来对集合做不同的抽象。

集合的方法：

boolean add(E e) ：将元素 e 放入到集合中
void clear() ：删除集合中的所有元素   
boolean contains(Object o)：如果此 collection 包含指定的元素，则返回 true
int size()：获得集合的长度
boolean remove(Object e) ：删除元素 e
Object[] toArray() ：返回一个装有所有集合中元素的数组

集合的遍历：

Iterator<E>：iterator()          //返回在此 collection 的元素上进行迭代的迭代器

boolean：hasNext()          //如果仍有元素，则返回 true
E：next()                         //返回迭代的下一个元素

//获得一个集合的迭代器对象，迭代器的对象的指针只能遍历一次 
//如果想再遍历一次，就再创建一个迭代器
//迭代器在遍历的过程中，不允许添加删除变更等操作（集合是不支持并发操作的）
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
	//获得这个元素
	Object obj=iterator.next();
}

List集合：

List是有序的集合，就像数组一样。我们可以把list理解为是一个长度可变的数组，而且提供了丰富的api。List的集合底层就是数组。
boolean add(E e)：尾插 e
void add(int index,E element)：将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)：尾插 c 中的元素
E remove(int index)：删除 index 位置元素
boolean remove(Object o)：删除遇到的第一个 o
E get(int index)：获取下标 index 位置元素
E set(int index,E element)：将下标 index 位置元素设置为 element
boolean contains(Object o)：判断 o 是否在线性表中
int indexOf(Object o))：获得某一个元素在集合中第一次出现的索引
int lastIndexOf(Object o))：获得某一个元素在集合中倒数第一次出现的索引
List<E> subList(int fromIndex,int toIndex)：截取部分 list

for 循环遍历 List
// i<list.size();  动态获取（可以在循环时，添加新的元素）
for(int i=0; i<  list.size() ;i++){
	//根据索引来获得对应的元素
	String str=(String)list.get(i);
	if("流淌".equals(str)){
		list.add("语音");
	}
} 

ArrayList：

ArrayList 的底层原理是 数组的原理。
List 接口的大小可变数组的实现。
实现了所有可选列表操作，并允许包括 null 在内的所有元素。
除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

特点：ArrayList 中的元素是可以重复的
           是有序的集合，长度不固定（ArrayList 在添加数据的时候初始的长度是10，后续会以5个长度来扩充集合的长度）
           不是线程安全的，适合不要求线程安全的需求来实现
           效率高

LinkedList：

LinkedList 是链表为原理，添加修改删除的性能高。
List 接口的链接列表实现。
实现所有可选的列表操作，并且允许所有元素（包括 null）。
除了实现 List 接口外，LinkedList 类还未在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。
这些操作允许将链接列表用作堆栈、队列 或 双端队列。
不是线程安全的。

栈：先进后出
队列：先进先出
链表：存储了元素和前后的地址

addFirst()：将指定元素插入此列表的开头
addLast()：将指定元素插入此列表的结尾
removeFirst()：移除第一个
removeLast()：移除最后 一个
pop()：从此列表所表示的堆栈处弹出一个元素
push()：将元素推入此列表所表示的堆栈

Vector：

Vector 的底层是数组。
Vector 与 ArrayList 的区别在于：Vector 是线程安全的。（但是 性能下降）

泛型：Generic

泛型就是在集合中指定存储的数据类型，而且只能存储这种类型。
在 List<类型> 必须要指定，ArrayList<>可以指定也可以不指定。
基本数据类型不能作为泛型（可以写它的包装类）。

定义集合：
List<数据类型> 变量名=new ArrayList<数据类型>();
//定义一个集合里面指定只能存储一种数据类型
List<String> list=new ArrayList<>();

自定义泛型：
class/interface 类名/接口名<T>{
}
T 只是泛型的一个标准，使用什么字符都可以，但是都要大写，不要使用特殊字符，建议用 T
//
public class GenericTest<T>{
	//定义一个泛型的属性
	private T t;
	public T getT(){
		return t;
	}
	public void setT(T t){
		this.t=t;
	}
}

总结：
1. 泛型是为了解决某些容器、算法等代码的通用性而引入，并且能在编译期间做类型检查。 
2. 泛型利用的是 Object 是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。 
3. 泛型是一种编译期间的机制，即 MyArrayList<Person> 和 MyArrayList<Book> 在运行期间是一个类型。 
4. 泛型是 java 中的一种合法语法，标志就是尖括号 <>

增强的 for 循环：

对数组、集合来做遍历
for(数据类型 变量：集合变量){
}
数据类型是集合或者数组中的数的类型
特点：遍历是存在并发问题（不支持并发，即：在循环里不支持一边遍历，一边修改值），如果有并发的需求请使用普通的 for 循环


String[] strs={"我的","小","可爱"};
for(String str:strs){
	sout(str);
}

List<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
for(int i=0;i<list.size();i++){
	//根据索引来获得集合的元素
	Integer val=list.get(i);
	//如果某个元素是2，就在这个集合里加入一个10
	if(val.equals(2)){
		list.add(10);
	}
	sout(val);
}

Set：

一个不包含重复元素的 collection，
即：set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。

HashSet：

此类实现 Set 接口，由哈希表支持。
它不保证 set 的迭代顺序：特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

特点：
元素唯一性（set 的元素是不可重复的，如果重复了就会自动的去掉）
无序行
允许 null 存在一个
不是线程安全（效率高）

HashSet 的唯一性：
在 HashSet 做添加的时候，会逐个来判断当前集合中的对象和要添加的对象的比较
通过以下的条件判断两个对象是否相等
*e.hash=hash && ((k=e.key)==key || key.equals(k))
*hash 值必须相等并且两个对象的地址相等或者equals返回true（如果对象的 hash 值和 equals 都相等那么就是重复的对象）

注意：
当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，
该协定声明相等对象必须具有相等的哈希码。

LinkedHashSet：

具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
与 HashSet 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。
此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。

特点：
元素唯一性
有序的
允许 null 存在一个
不是线程安全（效率高）

TreeSet：

TreeSet 可以支持自定义排序，如果 treeSet 所存储的对象的类没有实现 Comparable 接口就会报错 ClassCastException。
所以我们如果想要使用 TreeSet 来对自定义的对象来排序必须实现 Comparable 接口。

特点：
元素唯一性
可自定义排序的
不允许 null 存在
不是线程安全（效率高）

1. 排序比较
    类如果要实现比较的规则都会实现 Comparable 接口
    public interface Comparable<T>{
    	public int compareTo(T o);
    }
    
    String 对 CompareTo 的实现：
    public int CompareTo(String anotherString){
    	int len1=vlaue.length;
    	int len2=anotherString.value.length;
    	int lim=Math.min(len1,len2);
    	char[] v1=value;
    	char[] v2=anotherString.value;
    	
    	int k=0;
    	while(k<lim){
    		char c1=v1[k];
    		char c2=v2[k];
    		if(c1!=c2){
    			return c1-c2;
    		}
    		k++;
    	}
    	reuturn len1-len2;
    }
    
    字符串比较：
    String str="abc";
    String str1="ab";
    int i=str.compareTo(str1); 

可变参数：

//数据类型...变量（这是可变参数的定义方式）
//可以代表数组，还可以代表单个数的传递
//如果调用的时候，发现了正好匹配的方法就不会调用可变参数的方法，
//如果不存在一个正好调用的方法就会调用可变参数的方法

修饰符 返回值类型 方法名（数据类型...变量）{
}
public static int add(int...a){
}

工具类 Arrays：

数组的工具类，这里的方法都是静态的
1. 把数组转换成字符串
    static String：Arrays.toString(int[] a / Object[] a / double[] a)    // 返回指定数组内容的字符串表示形式

2. 对任意数组排序
    static void：Arrays.sort(int[] a / Object[] a / double[] a);          //按数字升序进行排序

3. 对任意的数组做成二分法的查找
    static int：Arrays.binarySearch(int[] a,int key)       

4. 把数组转换成List
    List<>：Arrays.asList()
    //不能把基本数据类型的数组转换成集合，如果要是传递了基本数据类型的集合，就会把数组的类型作为泛型
    Integer[] arr={1,2,4,5,6};
    List<Integer> integers=Arrays.asList(arr);

工具类Collections：

Collection 和 Collections 的区别：
前者是集合的接口
后者操作集合的工具类

map 集合 和Collection 集合的区别？
Map 集合 和 Collection 接口无关
1. Map 集合是键值对的集合，Collection 是单一出现的数据的集合
2. Map 的键唯一的，而 Collection 的子接口List集合中的元素是可以重复的，set是唯一的
3. Map 是夫妻对，Collection 是光棍 

Map：

Map 即 使键值对的集合的接口抽象
通过 key 的值来获得相应的值，将键映射到值的对象。
一个映射不能包含重复的键：每个键最多只能映射到一个值。
键只允许有一个空值，值可以有多个空值。

Map<K,V>
K、V 表示泛型
K：此映射所维护的键的类型
V：映射值的类型

Map 的特点：
1. 数据成对出现
2. 数据的键 key 是唯一的
3. 一个键 key 只能对应一个值（如果存在重复的key，就会把之前的覆盖掉）
4. 值 value 可以重复
5. 键 key 允许有一个为空，值 value 可以多个是空
6. Map 也是无序的

V get(Object key)：返回指定键所映射的值，如果此映射不包含该键的映射关系，则返回 null
V put(K key,V value)：将指定的值与此映射中的指定键关联
V getOrDefault(Object k,V defaultValue)：根据指定的 k 查找对应的 v，没有找到用默认值代替
boolean containsKey(Object Key)：判断是否包含key
boolean containsValue(Object value)：判断是否包含 value
map.clear();：清空集合
remove(Object key)：删除映射关系（删除键）
Set<K>：keySet()：获得一个 map 的集合的 key 的 set 集合

例：
Map<String,String> map=new HashMap<>();
map.put("校卡","我的");

Set<String> strings=map.keySet();
//遍历 map 集合
for(String key:strings){
	//根据遍历的 key 获得对应的 map 中的 value
	String value=map.get(key);
	sout(key+" "+value);
}

boolean：containsKey(Object key)：判断 map 集合是否包含指定的 key
boolean：containsValue(Object value)：判断 map 集合是否包含指定的 value
boolean：isEmpty()：如果此映射未包含 键-值 映射关系，返回 true
Set<Map.Entry<K,V>>：entrySet()：返回此映射中包含的映射关系的 Set 视图

Set<Map.Entry<String,String>> entries=map.entrySet();
for(Map.Entry<String,String> entry:entries){
	//获得 map 的元素的 key
	String key=entry.getKey();
	//获得 map 的元素的 value
	String value=entry.getValue();
}

HashMap：

特点：
1. HashMap 是 map 的实现类
2. 允许多个 null 值和一个 null 键
3. HashMap 中的元素没有顺序（跟添加的顺序无关）
4. HashMap 不是线程安全的

TreeMap：

Map<String,String> map=new TreeMap<>();

该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序（取决于使用的构造方法）

特点：
可以按着 key 来做排序
Key 不能 null，key 不能重复，值可以有多个 null
不是线程安全的

HashTable：

特点：
1. HashTable 是 map 的实现类
2. 不允许任何 null 值和 null 键
3. HashTable 中的元素没有顺序（跟添加的顺序无关）
4. HashTable 是线程安全的

LinkedHashMap：

特点：
1. LinkedHashMap 是 map 的实现类
2. 允许多个 null 值和一个 null 键
3. LinkedHashMap 有顺序（添加的顺序）
4. LinkedHashMap 不是线程安全的

文件 File：

File 的构造器：
文件的构造器是用来创建文件对象的，要保证文件路径的正确性

File(String pathname)：File file1=new File("D:\\aaa");
File(File parent,String child)：File file2=new File(file1,"tx.txt");
File(String parent,String child)：File file3=new File("D:\\aaa","tx.txt");

创建文件：

boolean：createNewFile()：当且仅当不存在具有此抽象类路径名指定名称的文件时，不可分地创建一个新的空文件

创建目录,其上一次路径要正确：
boolean：mkdir();
File file=new File("....");
boolean result=file.mkdir(); 

删除文件：

boolean：delete()
// 程序删除 不走回收站（回收站里没有，需要注意）
// 删除路径的最后一层
// 只有空目录才能被删除

文件的判断：

exists()：判断文件是否存在
isFile()：判断这个文件对象是否是文件
isDirectory()：判断这个文件对象是否是目录
isAbsolute()：判断这个文件对象是否是绝对路径

canRead()：文件是否可读
canWrite()：文件是否可写
isHidden()：是否是一个隐藏文件