前言
在看这篇文章之前先预习java基础
这部分知识一共有4个文档
第三个是当前这个文档
关于这部分的源码如下
javase从入门到精通的学习代码.rar
5. 集合
讲述集合的时候，如果对python感兴趣
也可以对比一下两者的不同
python数据类型详细分析（附代码）
- 集合实际上就是一个容器。可以来容纳其它类型的数据
- 集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）
list.add(100); //自动装箱Integer - 不同的集合等同于使用了不同的数据结构
new ArrayList(); 创建一个集合，底层是数组
new LinkedList(); 创建一个集合对象，底层是链表
new TreeSet(); 创建一个集合对象，底层是二叉树- 所有的集合类和集合接口都在java.util包下
5.1 集合两大类
==一类是单个方式存储元素：单个方式存储元素，这一类集合中超级父接口：java.util.Collection;==
==Collection接口继承Iterable接口（此接口有Iterator方法）==
调用此方法得到迭代器对象，执行方法下的三个函数 ==hasNext，next和remove==
list和set集合继承了collection接口，接口是不可以new的
- list接口主要常用的实现类有
ArrayList集合底层采用了数组这种数据结构，非线程安全。
- LinkedList集合底层采用了双向链表的数据结构
- Vector集合底层采用了数组这种数据结构，线程安全的，所有的方法都有synchronized关键字修饰，比较安全但效率低，所以使用率低
set接口主要常用的实现类有
- HashSet集合在new的时候，底层实际上new了一个HashMap集合。向HashSet集合中存储元素，实际上是存储到HashMap集合中，HashMap集合是一个哈希表数据结构
- TreeSet集合实际是TreeMap，new TreeSet集合的时候，底层实际上new了一个TreeMap集合，和上面同理。采用了二叉树数据结构
- Sortset接口特点
- 继承了Set结合，本身特点是无序不可重复，但是放在了SortedSet集合中的元素可以自动排序，是自动按照大小进行排序
==一类是以键值对儿的方式存储元素：以键值对的方式存储元素，这一类集合中超级父接口：java.util.Map;==
Map集合和Collection集合没有关系，存储的方式不同
所有Map集合key元素无序不可重复
Map接口的常用实现类有
- HashMap集合底层是哈希表数据结构，非线程安全
- Hashtable集合是哈希表数据结构，线程安全，所有的方法都有synchronized关键字，效率比较低，使用比较少了
- 还有一个接口SortedMap，本身不可重复无序，但是此处有自动排序，按照大小进行排序。此接口的实现类有TreeMap（二叉树结构）
总结：
所有的实现类：
| 实现类 | 底层元素 |
|---|---|
| Arraylist | 底层是数组。 |
| LinkedList | 底层是双向链表。 |
| Vector | 底层是数组，线程安全的，效率较低，使用较少。 |
| HashSet | 底层是HashMap，放到 HashSet集合中的元素等同于放到HashMap集合key部分了。 |
| TreeSet | 底层是TreeMap，放到 TreeSet集合中的元素等同于放到TreeMap集合key部分了。 |
| HashMap | 底层是哈希表。 |
| Hashtable | 底层也是哈希表，只不过线程安全的，效率较低，使用较少。 |
| Properties | 是线程安全的，并且 key 和value只能存储字符串String。 |
| TreeMap | 底层是二叉树。TreeMap集合的 key可以自动按照大小顺序排序。 |
集合的总体概念如下：
- set集合存储元素的特点:
无序不可重复
无序:存进去的顺序和取出的顺序不一定相同。另外 set集合中元素没有下标。
不可重复:存进去1，不能再存储1了。
- SortedSet ( SortedMap）集合存储元素特点:
无序不可重复的，但是SortedSet集合中的元素是可排序的。
无序:存进去的顺序和取出的顺序不一定相同。另外 set集合中元素没有下标。
不可重复:存进去1，不能再存储1
可排序:可以按照大小顺序排列。
- Map集合的 key，就是一个set集合。
往set集合中放数据，实际上放到了Map集合的 key 部分。
5.2 Collection
==集合中不能直接存储基本数据类型，也不能存java对象，只是存储java对象的内存地址。==
collection是一个接口
- 没有使用“泛型”之前，Collection中可以存储Object的所有子类型。
- 使用了“泛型”之后，Collection中只能存储某个具体的类型。
5.2.1 常用方法
常用方法有：
| 函数 | 功能 |
|---|---|
| boolean add(Object e) | 向集合中添加元素 |
| int size() | 获取集合中元素的个数 |
| void clear() | 清空集合 |
| boolean contains(Object o) | 判断当前集合中是否包含元素o，包含返回true，不包含返回false |
| boolean remove(Object o) | 删除集合中的某个元素。 |
| boolean isEmpty() | 判断该集合中元素的个数是否为0 |
| Object[] toArray() | 调用这个方法可以把集合转换成数组。【作为了解，使用不多。】 |
下面举例常用方法的注意事项
add方法中可以添加常用的数据，也可以==new对象==
Collection c = new ArrayList();
c.add(1200); // 自动装箱(java5的新特性。),实际上是放进去了一个对象的内存地址。Integer x = new Integer(1200);
c.add(3.14); // 自动装箱
c.add(new Object());
c.add(new Student());
c.add(true); // 自动装箱
c.add("hello"); // "hello"对象的内存地址放到了集合当中size()返回的是元素的个数
clear可以清空所有元素
contains返回的是boolean类型
5.2.2 迭代器
讲解collection的集合迭代，而且迭代器是通用的
这个迭代器是Collection的上层接口Iterator，而且迭代器一开始没有指向第一个元素
迭代器是对象，迭代器常用的两个方法为
- boolean hasNext()如果仍有元素可以迭代，则返回 true。
- Object next() 返回迭代的下一个元素
具体步骤为：
最开始先获取集合对象 Collection c = new ArrayList();
这个对象有iterator()方法。
通过集合对象调用迭代器的接口（接口方法返回接口）Iterator it = c.iterator();
在调用迭代器的方法
这个只能返回object， Object obj = it.next();
而且在输出的时候输出的是obj的内容，因为重写了tosting方法
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器。
一定要注意：集合结构只要发生改变，迭代器必须重新获取。
当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时：java.util.ConcurrentModificationException不可以这样子
// 获取迭代器
//Iterator it = c.iterator();
/*while(it.hasNext()){
// 编写代码时next()方法返回值类型必须是Object。
// Integer i = it.next();
Object obj = it.next();
System.out.println(obj);
}*/关于集合中迭代的代码展示
/*
关于集合的迭代/遍历
*/
public class CollectionTest03 {
public static void main(String[] args) {
// 创建集合对象
Collection c1 = new ArrayList(); // ArrayList集合：有序可重复
// 添加元素
c1.add(1);
c1.add(2);
c1.add(3);
c1.add(4);
c1.add(1);
// 迭代集合
Iterator it = c1.iterator();
while(it.hasNext()){
// 存进去是什么类型，取出来还是什么类型。
Object obj = it.next();
/*if(obj instanceof Integer){
System.out.println("Integer类型");
}*/
// 只不过在输出的时候会转换成字符串。因为这里println会调用toString()方法。
System.out.println(obj);
}
// HashSet集合：无序不可重复
Collection c2 = new HashSet();
// 无序：存进去和取出的顺序不一定相同。
// 不可重复：存储100，不能再存储100.
c2.add(100);
c2.add(200);
c2.add(300);
c2.add(90);
c2.add(400);
c2.add(50);
c2.add(60);
c2.add(100);
Iterator it2 = c2.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
}
}==hashset无序不可重复，而ArrayList有序可重复==
不可重复，就是不能重复add进相同的数字
5.2.3 contains方法
深入contains方法
判断集合中是否包含某个元素
==比较的是内容，是因为内部中调用了equals方法进行比对==
==String类的equals方法比较的是内容不是内存地址==
object类的equals比较的是地址
主要是因为string类的equals重写了，比较的是内容
可以通过代码进行比较
代码展示
public class CollectionTest04 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();
// 向集合中存储元素
String s1 = new String("abc"); // s1 = 0x1111
c.add(s1); // 放进去了一个"abc"
String s2 = new String("def"); // s2 = 0x2222
c.add(s2);
// 集合中元素的个数
System.out.println("元素的个数是：" + c.size()); // 2
// 新建的对象String
String x = new String("abc"); // x = 0x5555
// c集合中是否包含x？结果猜测一下是true还是false？、
System.out.println(c.contains(x)); //判断集合中是否存在"abc" true，结果为true就有
}
}
contains主要是因为重写equals方法，所以比较的是内容
查看源码也可看出重写了equals方法
而且通过自个定义函数重写
public class CollectionTest05 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();
// 创建用户对象
User u1 = new User("jack");
// 加入集合
c.add(u1);
// 判断集合中是否包含u2
User u2 = new User("jack");
// 没有重写equals之前：这个结果是false
//System.out.println(c.contains(u2)); // false
// 重写equals方法之后，比较的时候会比较name。
System.out.println(c.contains(u2)); // true
}
}
class User{
private String name;
public User(){}
public User(String name){
this.name = name;
}
// 重写equals方法
// 将来调用equals方法的时候，一定是调用这个重写的equals方法。
// 这个equals方法的比较原理是：只要姓名一样就表示同一个用户。
public boolean equals(Object o) {
if(o == null || !(o instanceof User)) return false;
if(o == this) return true;
User u = (User)o;
// 如果名字一样表示同一个人。（不再比较对象的内存地址了。比较内容。）
return u.name.equals(this.name);
}
}5.2.4 remove方法
==remove方法也是重写了equals方法==
如果删除某个元素，这个元素有两个一摸一样的
删除这个，这两个元素都会删除
// 创建集合对象
Collection cc = new ArrayList();
// 创建字符串对象
String s1 = new String("hello");
// 加进去。
cc.add(s1);
// 创建了一个新的字符串对象
String s2 = new String("hello");
// 删除s2
cc.remove(s2); // s1.equals(s2) java认为s1和s2是一样的。删除s2就是删除s1。
// 集合中元素个数是？
System.out.println(cc.size()); // 0前面也讲过迭代器中途不可以改变一点变化
如果改变了会出错
比如下面的代码展示
Collection c2 = new ArrayList();
c2.add("abc");
c2.add("def");
c2.add("xyz");
Iterator it2 = c2.iterator();
while(it2.hasNext()){
Object o = it2.next();
// 删除元素
// 删除元素之后，集合的结构发生了变化，应该重新去获取迭代器
// 但是，循环下一次的时候并没有重新获取迭代器，所以会出现异常：java.util.ConcurrentModificationException
// 出异常根本原因是：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化了）
//c2.remove(o); // 直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不同。）
// 使用迭代器来删除可以吗？
// 迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）。
it2.remove(); // 删除的一定是迭代器指向的当前元素。
System.out.println(o);
}
System.out.println(c2.size()); //0- 使用集合中的删除方法，出异常根本原因是：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化了）
- 使用迭代器自带的删除，迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）
主要是集合中删除的方法只是集合快照，如果有更新集合，会出现错误，如果使用的是迭代器的删除方法，如果有更新集合，集合也会随之更新而不影响删除的同步
5.3 List
List集合存储元素特点：有序可重复。有序：List集合中的元素有下标。从0开始，以1递增。重复：存储一个1，还可以再存储1.
List是Collection接口的子接口
以下只列出List接口特有的常用的方法：
| 常用方法 | 功能说明 |
|---|---|
| void add(int index, Object element) | 某个索引添加元素 |
| Object set(int index, Object element) | 某个索引设置元素 |
| Object get(int index) | 获取该索引的元素 |
| int indexOf(Object o) | 获取对象第一次出现的索引 |
| int lastIndexOf(Object o) | 获取对象最后一次出现的索引 |
| Object remove(int index) | 删除指定下标的元素 |
// 创建List类型的集合。
//List myList = new LinkedList();
//List myList = new Vector();
List myList = new ArrayList();
// 添加元素
myList.add("A"); // 默认都是向集合末尾添加元素。
myList.add("B");
myList.add("C");
myList.add("C");
myList.add("D");
//在列表的指定位置插入指定元素（第一个参数是下标）
// 这个方法使用不多，因为对于ArrayList集合来说效率比较低。
myList.add(1, "KING");
// 迭代
Iterator it = myList.iterator();
while(it.hasNext()){
Object elt = it.next();
System.out.println(elt);
}具体遍历元素也可以通过下标值
// 因为有下标，所以List集合有自己比较特殊的遍历方式
// 通过下标遍历。【List集合特有的方式，Set没有。】
for(int i = 0; i < myList.size(); i++){
Object obj = myList.get(i);
System.out.println(obj);
}其他方法比较简单，就不展示出代码
5.3.1 ArrayList
- 默认初始化容量10（底层先创建了一个长度为0的数组，当添加第一个元素的时候，初始化容量10。）
集合底层是一个Object[]数组。
- 构造方法：
new ArrayList();new ArrayList(20);
- 构造方法：
- ArrayList集合的扩容：增长到原容量的1.5倍。
==ArrayList集合底层是数组，尽可能少的扩容。因为数组扩容效率比较低，建议在使用ArrayList集合的时候预估计元素的个数，给定一个初始化容量==
- 数组优点：检索效率比较高。（每个元素占用空间大小相同，内存地址是连续的，通过数学表达式计算出元素的内存地址，检索效率高。）
- 数组缺点：随机增删元素效率比较低。另外数组无法存储大数据量。（很难找到一块非常巨大的连续的内存空间。）
- 向数组末尾添加元素，效率很高，不受影响。
==面试官经常问的一个问题？==
这么多的集合中，你用哪个集合最多？答：ArrayList集合。 因为往数组末尾添加元素，效率不受影响。 另外，我们检索/查找某个元素的操作比较多。- ArrayList集合是非线程安全的。（不是线程安全的集合。）
基本的代码实现
注意区分容量与数组的空间大小size
// 默认初始化容量是10
// 数组的长度是10
List list1 = new ArrayList();
// 集合的size()方法是获取当前集合中元素的个数。不是获取集合的容量。
System.out.println(list1.size()); // 0
// 指定初始化容量
// 数组的长度是20
List list2 = new ArrayList(20);
// 集合的size()方法是获取当前集合中元素的个数。不是获取集合的容量。
System.out.println(list2.size()); // 0构造方法除了以上两种之外 还有第三种转换方式
==将HashSet集合转换成List集合==
// 默认初始化容量10
List myList1 = new ArrayList();
// 指定初始化容量100
List myList2 = new ArrayList(100);
// 创建一个HashSet集合
Collection c = new HashSet();
// 添加元素到Set集合
c.add(100);
c.add(200);
c.add(900);
c.add(50);
// 通过这个构造方法就可以将HashSet集合转换成List集合。
List myList3 = new ArrayList(c);
for(int i = 0; i < myList3.size(); i++){
System.out.println(myList3.get(i));
}5.3.2 LinkedList
再讲这部分知识的时候，涉及单链表和双向链表以及对比线性表的区别
可查看我之前写过的文章
【数据结构】顺序表及链表详细分析（全）
具体单链表的创建和功能
简单阐述基本功能
创建链表
public class Link {
public static void main(String[] args) {
// 头节点
Node header;
int size = 0;
public int size(){
return size;
}
// 向链表中添加元素的方法（向末尾添加）
public void add(E data){
//public void add(Object data){
// 创建一个新的节点对象
// 让之前单链表的末尾节点next指向新节点对象。
// 有可能这个元素是第一个，也可能是第二个，也可能是第三个。
if(header == null){
// 说明还没有节点。
// new一个新的节点对象，作为头节点对象。
// 这个时候的头节点既是一个头节点，又是一个末尾节点。
header = new Node(data, null);
}else {
// 说明头不是空！
// 头节点已经存在了！
// 找出当前末尾节点，让当前末尾节点的next是新节点。
Node currentLastNode = findLast(header);
currentLastNode.next = new Node(data, null);
}
size++;
}
/**
* 专门查找末尾节点的方法。
*/
private Node findLast(Node node) {
if(node.next == null) {
// 如果一个节点的next是null
// 说明这个节点就是末尾节点。
return node;
}
// 程序能够到这里说明：node不是末尾节点。
return findLast(node.next); // 递归算法！
}
}创建单链表功能表述
/*
单链表中的节点。
节点是单向链表中基本的单元。
每一个节点Node都有两个属性：
一个属性：是存储的数据。
另一个属性：是下一个节点的内存地址。
*/
public class Node {
// 存储的数据
Object data;
// 下一个节点的内存地址
Node next;
public Node(){
}
public Node(Object data, Node next){
this.data = data;
this.next = next;
}
}
==通过以上代码可看出链表的优缺点：==
链表的优点：
由于链表上的元素在空间存储上内存地址不连续。
所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高。
在以后的开发中，如果遇到随机增删集合中元素的业务比较多时，建议使用LinkedList。
链表的缺点：
不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头节点开始遍历，直到找到为止。所以LinkedList集合检索/查找的效率较低。
LinkedList集合底层也是有下标的。
注意：ArrayList之所以检索效率比较高，不是单纯因为下标的原因。是因为底层数组发挥的作用。
LinkedList集合照样有下标，但是检索/查找某个元素的时候效率比较低，因为只能从头节点开始一个一个遍历。
List list = new LinkedList();
list.add("a");
list.add("b");
list.add("c");
for(int i = 0; i <list.size(); i++){
Object obj = list.get(i);
System.out.println(obj);
} List list2 = new ArrayList(); // 这样写表示底层用了数组
List list2 = new LinkedList(); // 这样写表示底层用了双向链表5.3.3 Vector
- 底层也是一个数组
- 初始化容量：10
- 怎么扩容的？
扩容之后是原容量的2倍。
10--> 20 --> 40 --> 80
- ArrayList集合扩容特点：ArrayList集合扩容是原容量1.5倍。
- Vector中所有的方法都是线程同步的，都带有synchronized关键字，是线程安全的。效率比较低，使用较少了。
==创建一个集合==
// 创建一个Vector集合
List vector = new Vector();
//Vector vector = new Vector();遍历集合数组
Iterator it = vector.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}使用非线程安全转换为线程安全
- 怎么将一个线程不安全的ArrayList集合转换成线程安全的呢？
使用集合工具类：
java.util.Collections;
这里区别一下：
java.util.Collection 是集合接口。
java.util.Collections 是集合工具类。
// 这个可能以后要使用！！！！
List myList = new ArrayList(); // 非线程安全的。
// 变成线程安全的
Collections.synchronizedList(myList); // 这里没有办法看效果，因为多线程没学，你记住先！
// myList集合就是线程安全的了。
myList.add("111");
myList.add("222");
myList.add("333");5.4 补充泛型机制
只在程序编译阶段起作用，只是给编译器参考的。（运行阶段泛型没用！）
泛型优点：
- 集合中存储的元素类型统一了。
- 从集合中取出的元素类型是泛型指定的类型，不需要进行大量的“向下转型”！
缺点：
- 导致集合中存储的元素缺乏多样性！
5.4.1 不使用泛型机制
在这之前必须掌握几个点
- 迭代器返回的最后类型是Object
- 向下转如果是它的子类型的话，就会执行，通过这个关键字
obj instanceof Animal，本身所有类都有继承object的
具体可看我这篇文章
java之instanceof用法详细分析（全）
public class GenericTest01 {
public static void main(String[] args) {
List myList = new ArrayList();
// 准备对象
Cat c = new Cat();
Bird b = new Bird();
// 将对象添加到集合当中
myList.add(c);
myList.add(b);
// 遍历集合，取出每个Animal，让它move
Iterator it = myList.iterator();
while(it.hasNext()) {
// 没有这个语法，通过迭代器取出的就是Object
//Animal a = it.next();
Object obj = it.next();
//obj中没有move方法，无法调用，需要向下转型！
if(obj instanceof Animal){
Animal a = (Animal)obj;
a.move();
}
}
}
}
class Animal {
// 父类自带方法
public void move(){
System.out.println("动物在移动！");
}
}
class Cat extends Animal {
// 特有方法
public void catchMouse(){
System.out.println("猫抓老鼠！");
}
}
class Bird extends Animal {
// 特有方法
public void fly(){
System.out.println("鸟儿在飞翔！");
}
}5.4.2 使用泛型机制
区别在于 如果使用了泛型机制的代码
可以不用强转化
但是调用子类的方法还是要进行强转换
// 使用JDK5之后的泛型机制
// 使用泛型List<Animal>之后，表示List集合中只允许存储Animal类型的数据。
// 用泛型来指定集合中存储的数据类型。
List<Animal> myList = new ArrayList<Animal>();
// 指定List集合中只能存储Animal，那么存储String就编译报错了。
// 这样用了泛型之后，集合中元素的数据类型更加统一了。
//myList.add("abc");
Cat c = new Cat();
Bird b = new Bird();
myList.add(c);
myList.add(b);
// 获取迭代器
// 这个表示迭代器迭代的是Animal类型。
Iterator<Animal> it = myList.iterator();
while(it.hasNext()){
// 使用泛型之后，每一次迭代返回的数据都是Animal类型。
//Animal a = it.next();
// 这里不需要进行强制类型转换了。直接调用。
//a.move();
// 调用子类型特有的方法还是需要向下转换的！
Animal a = it.next();
if(a instanceof Cat) {
Cat x = (Cat)a;
x.catchMouse();
}
if(a instanceof Bird) {
Bird y = (Bird)a;
y.fly();
}5.4.3 自动类型推断机制
ArrayList<这里的类型会自动推断>()，前提是JDK8之后才允许
List<Animal> myList = new ArrayList<>();添加对应的类型
myList.add(new Animal());
myList.add(new Cat());
myList.add(new Bird());
// 遍历
Iterator<Animal> it = myList.iterator();
while(it.hasNext()){
Animal a = it.next();
a.move();
}如果类型是string类型
则为
List<String> strList = new ArrayList<>();
// 类型不匹配。
//strList.add(new Cat());
strList.add("http://www.126.com");
strList.add("http://www.baidu.com");
strList.add("http://www.bjpowernode.com");
// 类型不匹配。
//strList.add(123);如果使用了泛型机制则可以不用强转换，返回的类型是对应的
// 遍历
Iterator<String> it2 = strList.iterator();
while(it2.hasNext()){
// 如果没有使用泛型
/*
Object obj = it2.next();
if(obj instanceof String){
String ss = (String)obj;
ss.substring(7);
}
*/
// 直接通过迭代器获取了String类型的数据
String s = it2.next();
// 直接调用String类的substring方法截取字符串。
String newString = s.substring(7);
System.out.println(newString);5.4.4 自定义泛型
自定义泛型的时候，<> 尖括号中的是一个标识符，随便写。
java源代码中经常出现的是：<E>和<T>。E是Element单词首字母。T是Type单词首字母。
根据自已定义的泛型，泛型可以随便写，但常用的就那两个字母
public class GenericTest03<标识符随便写> {
public void doSome(标识符随便写 o){
System.out.println(o);
}
public static void main(String[] args) {
// new对象的时候指定了泛型是：String类型
GenericTest03<String> gt = new GenericTest03<>();
// 类型不匹配
//gt.doSome(100);
gt.doSome("abc");
// =============================================================
GenericTest03<Integer> gt2 = new GenericTest03<>();
gt2.doSome(100);
// 类型不匹配
//gt2.doSome("abc");
MyIterator<String> mi = new MyIterator<>();
String s1 = mi.get();
MyIterator<Animal> mi2 = new MyIterator<>();
Animal a = mi2.get();
// 不用泛型就是Object类型。
/*GenericTest03 gt3 = new GenericTest03();
gt3.doSome(new Object());*/
}
}
class MyIterator<T> {
public T get(){
return null;
}
}5.4.5 补充foreach结构
foreach有一个缺点：没有下标。
在需要使用下标的循环中，不建议使用增强for循环
测试例子
public class ForEachTest01 {
public static void main(String[] args) {
// int类型数组
int[] arr = {432,4,65,46,54,76,54};
// 遍历数组（普通for循环）
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
// 增强for（foreach）
// 以下是语法
/*for(元素类型 变量名 : 数组或集合){
System.out.println(变量名);
}*/
System.out.println("======================================");
// foreach有一个缺点：没有下标。在需要使用下标的循环中，不建议使用增强for循环。
for(int data : arr) {
// data就是数组中的元素（数组中的每一个元素。）
System.out.println(data);
}
}
}==结合泛型的foreach结构类型例子==
public class ForEachTest02 {
public static void main(String[] args) {
// 创建List集合
List<String> strList = new ArrayList<>();
// 添加元素
strList.add("hello");
strList.add("world!");
strList.add("kitty!");
// 遍历，使用迭代器方式
Iterator<String> it = strList.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
// 使用下标方式（只针对于有下标的集合）
for(int i = 0; i < strList.size(); i++){
System.out.println(strList.get(i));
}
// 使用foreach
for(String s : strList){ // 因为泛型使用的是String类型，所以是：String s
System.out.println(s);
}
List<Integer> list = new ArrayList<>();
list.add(100);
list.add(200);
list.add(300);
for(Integer i : list){ // i代表集合中的元素
System.out.println(i);
}
}
}5.5 Set
无序不可重复
5.5.1 HashSet
- 存储时顺序和取出的顺序不同
- 不可重复
- 放到HashSet集合中的元素实际上是放到HashMap集合的key部分了
// 演示一下HashSet集合特点
Set<String> strs = new HashSet<>();
// 添加元素
strs.add("hello3");
strs.add("hello4");
strs.add("hello1");
strs.add("hello2");
strs.add("hello3");
strs.add("hello3");
strs.add("hello3");
strs.add("hello3");
// 遍历
/*
hello1
hello4
hello2
hello3
*/
for(String s : strs){
System.out.println(s);5.5.2 TreeSet
无序不可重复的，但是存储的元素可以自动按照大小顺序排序
这里的无序指的是存进去的顺序和取出来的顺序不同。并且没有下标
// 创建集合对象
Set<String> strs = new TreeSet<>();
// 添加元素
strs.add("A");
strs.add("B");
strs.add("Z");
strs.add("Y");
strs.add("Z");
strs.add("K");
strs.add("M");
// 遍历
/*
A
B
K
M
Y
Z
从小到大自动排序！
*/
for(String s : strs){
System.out.println(s);5.6 Map
- Map和Collection没有继承关系。
- Map集合以key和value的方式存储数据：键值对
key和value都是引用数据类型
key和value都是存储对象的内存地址
key起到主导的地位，value是key的一个附属品
5.6.1 常用方法
| 方法 | 表述 |
|---|---|
| V put(K key, V value) | 向Map集合中添加键值对 |
| V get(Object key) | 通过key获取value |
| void clear() | 清空Map集合 |
| boolean containsKey(Object key) | 判断Map中是否包含某个key |
| boolean containsValue(Object value) | 判断Map中是否包含某个value |
| boolean isEmpty() | 判断Map集合中元素个数是否为0 |
| V remove(Object key) | 通过key删除键值对 |
| int size() | 获取Map集合中键值对的个数。 |
| Collection values() | 获取Map集合中所有的value，返回一个Collection |
| Set keySet() | 获取Map集合所有的key（所有的键是一个set集合） |
| Set<Map.Entry<K,V>> entrySet() | 将Map集合转换成Set集合 |
主要的代码展示
public class MapTest01 {
public static void main(String[] args) {
// 创建Map集合对象
Map<Integer, String> map = new HashMap<>();
// 向Map集合中添加键值对
map.put(1, "zhangsan"); // 1在这里进行了自动装箱。
map.put(2, "lisi");
map.put(3, "wangwu");
map.put(4, "zhaoliu");
// 通过key获取value
String value = map.get(2);
System.out.println(value);
// 获取键值对的数量
System.out.println("键值对的数量：" + map.size());
// 通过key删除key-value
map.remove(2);
System.out.println("键值对的数量：" + map.size());
// 判断是否包含某个key
// contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法。
System.out.println(map.containsKey(new Integer(4))); // true
// 判断是否包含某个value
System.out.println(map.containsValue(new String("wangwu"))); // true
// 获取所有的value
Collection<String> values = map.values();
// foreach
for(String s : values){
System.out.println(s);
}
// 清空map集合
map.clear();
System.out.println("键值对的数量：" + map.size());
// 判断是否为空
System.out.println(map.isEmpty()); // true
}
}最后一个方法函数重点说明：
假设现在有一个Map集合，如下所示：
map1集合对象
key value
----------------------------
1 zhangsan
2 lisi
3 wangwu
4 zhaoliu
Set set = map1.entrySet();
set集合对象
1=zhangsan 【注意：Map集合通过entrySet()方法转换成的这个Set集合，Set集合中元素的类型是 Map.Entry<K,V>】
2=lisi 【Map.Entry和String一样，都是一种类型的名字，只不过：Map.Entry是静态内部类，是Map中的静态内部类】
3=wangwu
4=zhaoliu ---> 这个东西是个什么？Map.Entry
所谓的静态内部类可以通过下面这个代码进行理解
public class MyClass {
// 声明一个静态内部类
private static class InnerClass {
// 静态方法
public static void m1(){
System.out.println("静态内部类的m1方法执行");
}
// 实例方法
public void m2(){
System.out.println("静态内部类中的实例方法执行！");
}
}
public static void main(String[] args) {
// 类名叫做：MyClass.InnerClass
MyClass.InnerClass.m1();
// 创建静态内部类对象
MyClass.InnerClass mi = new MyClass.InnerClass();
mi.m2();
// 给一个Set集合
// 该Set集合中存储的对象是：MyClass.InnerClass类型
Set<MyClass.InnerClass> set = new HashSet<>();
// 这个Set集合中存储的是字符串对象。
Set<String> set2 = new HashSet<>();
Set<MyMap.MyEntry<Integer, String>> set3 = new HashSet<>();
}
}
class MyMap {
public static class MyEntry<K,V> {
}
}
5.6.2 集合遍历
==第一种方式：获取所有的key，通过遍历key，来遍历value==
Map<Integer, String> map = new HashMap<>();
map.put(1, "zhangsan");
map.put(2, "lisi");
map.put(3, "wangwu");
map.put(4, "zhaoliu");
// 遍历Map集合
// 获取所有的key，所有的key是一个Set集合
Set<Integer> keys = map.keySet();遍历key，通过key获取value
- 迭代器可以
Iterator<Integer> it = keys.iterator();
while(it.hasNext()){
// 取出其中一个key
Integer key = it.next();
// 通过key获取value
String value = map.get(key);
System.out.println(key + "=" + value);
}- foreach也可以
for(Integer key : keys){
System.out.println(key + "=" + map.get(key));
}==第二种方式：Set<Map.Entry<K,V>> entrySet()==
以上这个方法是把Map集合直接全部转换成Set集合。
// Set集合中元素的类型是：Map.Entry
Set<Map.Entry<Integer,String>> set = map.entrySet();
// 遍历Set集合，每一次取出一个Node
// 迭代器
/*Iterator<Map.Entry<Integer,String>> it2 = set.iterator();
while(it2.hasNext()){
Map.Entry<Integer,String> node = it2.next();
Integer key = node.getKey();
String value = node.getValue();
System.out.println(key + "=" + value);
}*/
// foreach
// 这种方式效率比较高，因为获取key和value都是直接从node对象中获取的属性值。
// 这种方式比较适合于大数据量。
for(Map.Entry<Integer,String> node : set){
System.out.println(node.getKey() + "--->" + node.getValue());
}5.6.3 HashMap
- 底层是哈希表/散列表的数据结构。
- 哈希表是一个数组和单向链表的结合体。
数组：在查询方面效率很高，随机增删方面效率很低。
单向链表：在随机增删方面效率较高，在查询方面效率很低。
哈希表将以上的两种数据结构融合在一起，充分发挥它们各自的优点 - HashMap集合底层的源代码：
public class HashMap{
// HashMap底层实际上就是一个数组。（一维数组）
Node<K,V>[] table;
// 静态的内部类HashMap.Node
static class Node<K,V> {
final int hash; // 哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组的下标。）
final K key; // 存储到Map集合中的那个key
V value; // 存储到Map集合中的那个value
Node<K,V> next; // 下一个节点的内存地址。
}
}哈希表/散列表：一维数组，这个数组中每一个元素是一个单向链表。（数组和链表的结合体。）
- HashMap集合的key部分特点：无序，不可重复。
为什么无序？ 因为不一定挂到哪个单向链表上。
不可重复是怎么保证的？ equals方法来保证HashMap集合的key不可重复。如果key重复了，value会覆盖。
- 哈希表HashMap使用不当时无法发挥性能！
1.假设将所有的hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了纯单向链表。这种情况我们成为：散列分布不均匀。 什么是散列分布均匀？假设有100个元素，10个单向链表，那么每个单向链表上有10个节点，这是最好的， 是散列分布均匀的。
2.假设将所有的hashCode()方法返回值都设定为不一样的值，这样的话导致底层哈希表就成为一维数组了，没有链表的概念了。也是散列分布不均匀。
散列分布均匀需要你重写hashCode()方法时有一定的技巧。
- HashMap集合的默认初始化容量是16，默认加载因子是0.75
这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组开始扩容。==HashMap集合初始化容量必须是2的倍数，这也是官方推荐的，这是因为达到散列均匀，为了提高HashMap集合的存取效率，所必须的。==
==最主要掌握的是：==
map.put(k,v)
v = map.get(k)
以上这两个方法的实现原理
测试HashMap集合key部分的元素特点
// Integer是key，它的hashCode和equals都重写了。
Map<Integer,String> map = new HashMap<>();
map.put(1111, "zhangsan");
map.put(6666, "lisi");
map.put(7777, "wangwu");
map.put(2222, "zhaoliu");
map.put(2222, "king"); //key重复的时候value会自动覆盖。
System.out.println(map.size()); // 4
// 遍历Map集合
Set<Map.Entry<Integer,String>> set = map.entrySet();
for(Map.Entry<Integer,String> entry : set){
// 验证结果：HashMap集合key部分元素：无序不可重复。
System.out.println(entry.getKey() + "=" + entry.getValue());- 放在HashMap集合key部分的元素其实就是放到HashSet集合中了。所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。
==此处重点讲解一下==
向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法！
equals方法有可能调用，也有可能不调用。
put(k,v)和get(k)举例，什么时候equals不会调用？ k.hashCode()方法返回哈希值，哈希值经过哈希算法转换成数组下标。数组下标位置上如果是null，equals不需要执行。
注意：如果一个类的equals方法重写了，那么hashCode()方法必须重写。
并且equals方法返回如果是true，hashCode()方法返回的值必须一样。
equals方法返回true表示两个对象相同，在同一个单向链表上比较。
那么对于同一个单向链表上的节点来说，他们的哈希值都是相同的。
所以hashCode()方法的返回值也应该相同。
对于哈希表数据结构来说：
如果o1和o2的hash值相同，一定是放到同一个单向链表上。
当然如果o1和o2的hash值不同，但由于哈希算法执行结束之后转换的数组下标可能相同，此时会发生“哈希碰撞”。重写equals与hashcode两者进行比较的测试代码
Student s1 = new Student("zhangsan");
Student s2 = new Student("zhangsan");
// 重写equals方法之前是false
//System.out.println(s1.equals(s2)); // false
// 重写equals方法之后是true
System.out.println(s1.equals(s2)); //true （s1和s2表示相等）
System.out.println("s1的hashCode=" + s1.hashCode()); //284720968 (重写hashCode之后-1432604525)
System.out.println("s2的hashCode=" + s2.hashCode()); //122883338 (重写hashCode之后-1432604525)
// s1.equals(s2)结果已经是true了，表示s1和s2是一样的，相同的，那么往HashSet集合中放的话，
// 按说只能放进去1个。（HashSet集合特点：无序不可重复）
Set<Student> students = new HashSet<>();
students.add(s1);
students.add(s2);
System.out.println(students.size()); // 这个结果按说应该是1. 但是结果是2.显然不符合HashSet集合存储特点。怎么办？重写的类主要代码
public class Student {
private String name;
public Student() {
}
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// hashCode
// equals（如果学生名字一样，表示同一个学生。）
/*public boolean equals(Object obj){
if(obj == null || !(obj instanceof Student)) return false;
if(obj == this) return true;
Student s = (Student)obj;
return this.name.equals(s.name);
}*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name);
}
}
5.6.4 Hashtable
- Hashtable的key和value都是不能为null的。
HashMap集合的key和value都是可以为null的。
- Hashtable方法都带有synchronized：线程安全的。
线程安全有其它的方案，这个Hashtable对线程的处理
导致效率较低，使用较少了。
- Hashtable和HashMap一样，底层都是哈希表数据结构。
Hashtable的初始化容量是11，默认加载因子是：0.75f
Hashtable的扩容是：原容量 * 2 + 1
这个会出错
Map map = new Hashtable();
//map.put(null, "123");
map.put(100, null);这个不会出错
Map map = new HashMap();
// HashMap集合允许key为null
map.put(null, null);
System.out.println(map.size()); // 1
// key重复的话value是覆盖！
map.put(null, 100);
System.out.println(map.size()); //1
// 通过key获取value
System.out.println(map.get(null)); // 1005.6.5 properties
Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。
Properties被称为属性类对象。
Properties是线程安全的。
// 创建一个Properties对象
Properties pro = new Properties();
// 需要掌握Properties的两个方法，一个存，一个取。
pro.setProperty("url", "jdbc:mysql://localhost:3306/bjpowernode");
pro.setProperty("driver","com.mysql.jdbc.Driver");
pro.setProperty("username", "root");
pro.setProperty("password", "123");
// 通过key获取value
String url = pro.getProperty("url");
String driver = pro.getProperty("driver");
String username = pro.getProperty("username");
String password = pro.getProperty("password");
System.out.println(url);
System.out.println(driver);
System.out.println(username);
System.out.println(password);5.6.6 TreeMap
- TreeSet集合底层实际上是一个TreeMap
TreeMap集合底层是一个二叉树。
放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了。
- TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序。称为：可排序集合。
// 创建一个TreeSet集合
TreeSet<String> ts = new TreeSet<>();
// 添加String
ts.add("zhangsan");
ts.add("lisi");
ts.add("wangwu");
ts.add("zhangsi");
ts.add("wangliu");
// 遍历
for(String s : ts){
// 按照字典顺序，升序！
System.out.println(s);
}
TreeSet<Integer> ts2 = new TreeSet<>();
ts2.add(100);
ts2.add(200);
ts2.add(900);
ts2.add(800);
ts2.add(600);
ts2.add(10);
for(Integer elt : ts2){
// 升序！
System.out.println(elt);==对自定义的类型来说，TreeSet可以排序吗？
以下程序中对于Person类型来说，无法排序。因为没有指定Person对象之间的比较规则==
以下程序运行的时候出现了这个异常：
java.lang.ClassCastException:
class com.bjpowernode.javase.collection.Person
cannot be cast to class java.lang.Comparable出现这个异常的原因是：
Person类没有实现java.lang.Comparable接口。
程序如下
public class TreeSetTest03 {
public static void main(String[] args) {
person p1 = new person(32);
//System.out.println(p1);
person p2 = new person(20);
person p3 = new person(30);
person p4 = new person(25);
// 创建TreeSet集合
TreeSet<person> persons = new TreeSet<>();
// 添加元素
persons.add(p1);
persons.add(p2);
persons.add(p3);
persons.add(p4);
// 遍历
for (person p : persons){
System.out.println(p);
}
}
}
class Person {
int age;
public Person(int age){
this.age = age;
}
// 重写toString()方法
public String toString(){
return "Person[age="+age+"]";
}
}
==第一种改写==
放在TreeSet集合中的元素需要实现java.lang.Comparable接口
需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较！
class Customer implements Comparable<Customer>{
int age;
public Customer(int age){
this.age = age;
}
// k.compareTo(t.key)
// 拿着参数k和集合中的每一个k进行比较，返回值可能是>0 <0 =0
// 比较规则最终还是由程序员指定的：例如按照年龄升序。或者按照年龄降序。
@Override
public int compareTo(Customer c) { // c1.compareTo(c2);
//return this.age - c.age; // =0 >0 <0
return c.age - this.age;
}
public String toString(){
return "Customer[age="+age+"]";
}
}
//具体改写的接口也可以这样定义
// this是c1
// c是c2
// c1和c2比较的时候，就是this和c比较。
/*int age1 = this.age;
int age2 = c.age;
if(age1 == age2){
return 0;
} else if(age1 > age2) {
return 1;
} else {
return -1;
}*/实现类如下
Customer c1 = new Customer(32);
Customer c2 = new Customer(20);
Customer c3 = new Customer(30);
Customer c4 = new Customer(25);
// 创建TreeSet集合
TreeSet<Customer> customers = new TreeSet<>();
// 添加元素
customers.add(c1);
customers.add(c2);
customers.add(c3);
customers.add(c4);
// 遍历
for (Customer c : customers){
System.out.println(c);另一个完整的案例可以参照如下程序
先按照年龄升序，如果年龄一样的再按照姓名升序
public class TreeSetTest05 {
public static void main(String[] args) {
TreeSet<Vip> vips = new TreeSet<>();
vips.add(new Vip("zhangsi", 20));
vips.add(new Vip("zhangsan", 20));
vips.add(new Vip("king", 18));
vips.add(new Vip("soft", 17));
for(Vip vip : vips){
System.out.println(vip);
}
}
}
class Vip implements Comparable<Vip>{
String name;
int age;
public Vip(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Vip{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
/*
compareTo方法的返回值很重要：
返回0表示相同，value会覆盖。
返回>0，会继续在右子树上找。【10 - 9 = 1 ，1 > 0的说明左边这个数字比较大。所以在右子树上找。】
返回<0，会继续在左子树上找。
*/
@Override
public int compareTo(Vip v) {
// 写排序规则，按照什么进行比较。
if(this.age == v.age){
// 年龄相同时按照名字排序。
// 姓名是String类型，可以直接比。调用compareTo来完成比较。
return this.name.compareTo(v.name);
} else {
// 年龄不一样
return this.age - v.age;
}
}
}
==第二种改写的方式==
使用比较器的方式
比较器要传入参数进去
TreeSet<WuGui> wuGuis = new TreeSet<>();//这样不行，没有通过构造方法传递一个比较器进去完整代码案例如下
public class TreeSetTest06 {
public static void main(String[] args) {
// 创建TreeSet集合的时候，需要使用这个比较器。
// TreeSet<WuGui> wuGuis = new TreeSet<>();//这样不行，没有通过构造方法传递一个比较器进去。
// 给构造方法传递一个比较器。
//TreeSet<WuGui> wuGuis = new TreeSet<>(new WuGuiComparator());
// 大家可以使用匿名内部类的方式（这个类没有名字。直接new接口。）
TreeSet<WuGui> wuGuis = new TreeSet<>(new Comparator<WuGui>() {
@Override
public int compare(WuGui o1, WuGui o2) {
return o1.age - o2.age;
}
});
wuGuis.add(new WuGui(1000));
wuGuis.add(new WuGui(800));
wuGuis.add(new WuGui(810));
for(WuGui wuGui : wuGuis){
System.out.println(wuGui);
}
}
}
// 乌龟
class WuGui{
int age;
public WuGui(int age){
this.age = age;
}
@Override
public String toString() {
return "小乌龟[" +
"age=" + age +
']';
}
}
// 单独在这里编写一个比较器
// 比较器实现java.util.Comparator接口。（Comparable是java.lang包下的。Comparator是java.util包下的。）
/*
class WuGuiComparator implements Comparator<WuGui> {
@Override
public int compare(WuGui o1, WuGui o2) {
// 指定比较规则
// 按照年龄排序
return o1.age - o2.age;
}
}
*/最终的结论：
放到TreeSet或者TreeMap集合key部分的元素要想做到排序,包括两种方式：
第一种：放在集合中的元素实现java.lang.Comparable接口。
第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。
Comparable和Comparator怎么选择呢？
当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。
如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口。Comparator接口的设计符合OCP原则。
5.7 collections工具类
java.util.Collection 集合接口
java.util.Collections 集合工具类，方便集合的操作。
==线程安全的集合转换为非线程安全==
// ArrayList集合不是线程安全的。
List<String> list = new ArrayList<>();
// 变成线程安全的
Collections.synchronizedList(list);==运用排序的函数==
// 排序
list.add("abf");
list.add("abx");
list.add("abc");
list.add("abe");
Collections.sort(list);
for(String s : list){
System.out.println(s);
}==自定义的要重写Comparable接口==
List<WuGui2> wuGuis = new ArrayList<>();
wuGuis.add(new WuGui2(1000));
wuGuis.add(new WuGui2(8000));
wuGuis.add(new WuGui2(500));
// 注意：对List集合中元素排序，需要保证List集合中的元素实现了：Comparable接口。
Collections.sort(wuGuis);
for(WuGui2 wg : wuGuis){
System.out.println(wg);
}
class WuGui2 implements Comparable<WuGui2>{
int age;
public WuGui2(int age){
this.age = age;
}
@Override
public int compareTo(WuGui2 o) {
return this.age - o.age;
}
@Override
public String toString() {
return "WuGui2{" +
"age=" + age +
'}';
}
}
==set集合如何进行排序==
// 对Set集合怎么排序呢？
Set<String> set = new HashSet<>();
set.add("king");
set.add("kingsoft");
set.add("king2");
set.add("king1");
// 将Set集合转换成List集合
List<String> myList = new ArrayList<>(set);
Collections.sort(myList);
for(String s : myList) {
System.out.println(s);
}
// 这种方式也可以排序。
//Collections.sort(list集合, 比较器对象);5.8 总结
一共有以上的集合元素
注意考察代码功能是
- 每个集合对象的创建（new）
- 向集合中添加元素
- 从集合中取出某个元素
- 遍历集合
5.8.1 概念总结
关于概念的总结，map这一块比较多，因为面试实在是太常考了
HashSet 如何检查重复
当你把对象加⼊ HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加⼊的位置，同时也会与其他加⼊的对象的 hashcode 值作⽐较，如果没有相符的 hashcode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调⽤ equals() ⽅法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让加⼊操作成功。
关于map的比较：
HashMap 和 Hashtable 的区别
- 线程是否安全： HashMap 是⾮线程安全的，HashTable 是线程安全的,因为 HashTable 内部的⽅法基本都经过 synchronized 修饰。（如果你要保证线程安全的话就使⽤ConcurrentHashMap 吧！）；
- 效率： 因为线程安全的问题，HashMap 要⽐ HashTable 效率⾼⼀点。另外，HashTable 基本被淘汰，不要在代码中使⽤它
- 对 Null key 和 Null value 的⽀持： HashMap 可以存储 null 的 key 和 value，但 null 作为键只能有⼀个，null 作为值可以有多个；HashTable 不允许有 null 键和 null 值，否则会抛出 NullPointerException
- 初始容量⼤⼩和每次扩充容量⼤⼩的不同 ： 创建时如果不指定容量初始值，Hashtable 默
认的初始⼤⼩为 11，之后每次扩充，容量变为原来的 2n+1。HashMap 默认的初始化⼤⼩为
16。之后每次扩充，容量变为原来的 2 倍。
HashMap 的底层实现
JDK1.8 之前 HashMap 底层是 数组和链表 结合在⼀起使⽤也就是 链表散列
JDK1.8 之后在解决哈希冲突时有了较⼤的变化，当链表⻓度⼤于阈值（默认为8）（将链表转换成红⿊树前会判断，如果当前数组的⻓度⼩于 64，那么会选择先进⾏数组扩容，⽽不是转换为红⿊树）时，将链表转化为红⿊树，以减少搜索时间
TreeMap、TreeSet 以及 JDK1.8 之后的 HashMap 底层都⽤到了红⿊树。红⿊树就是为了解决⼆叉
查找树的缺陷，因为⼆叉查找树在某些情况下会退化成⼀个线性结构
HashMap 的⻓度为什么是 2 的幂次⽅
为了能让 HashMap 存取⾼效，尽量较少碰撞，也就是要尽量把数据分配均匀
⽤之前还要先做对数组的⻓度取模运算，得到的余数才能⽤来要存放的位置也就是对应的数组下标。这个数组下标的计算⽅法是“ (n - 1) & hash ”。
hash%length==hash&(length-1)的前提是 length 是 2的 幂次⽅
ConcurrentHashMap 和 Hashtable 的区别
- 底层数据结构： JDK1.7 的 ConcurrentHashMap 底层采⽤ 分段的数组+链表 实现，JDK1.8 采⽤的数据结构跟 HashMap1.8 的结构⼀样，数组+链表/红⿊⼆叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采⽤ 数组+链表 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突⽽存在的
- 实现线程安全的⽅式（重要）： ① 在 JDK1.7 的时候，ConcurrentHashMap（分段锁） 对整个桶数组进⾏了分割分段(Segment)，每⼀把锁只锁容器其中⼀部分数据，多线程访问容器⾥不同数据段的数据，就不会存在锁竞争，提⾼并发访问率。 到了 JDK1.8 的时候已经摒弃了Segment 的概念，⽽是直接⽤ Node 数组+链表+红⿊树的数据结构来实现，并发控制使⽤synchronized 和 CAS 来操作。（JDK1.6 以后 对 synchronized 锁做了很多优化） 整个看起来就像是优化过且线程安全的 HashMap，虽然在 JDK1.8 中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② Hashtable(同⼀把锁) :使⽤ synchronized 来保证线程安全，效率⾮常低下。当⼀个线程访问同步⽅法时，其他线程也访问同步⽅法，可能会进⼊阻塞或轮询状态，如使⽤ put 添加元素，另⼀个线程不能使⽤ put 添加元素，也不能使⽤get，竞争会越来越激烈效率越低
5.8.2 代码总结
==ArrayList和linkedlist==
// 创建集合对象
//ArrayList<String> list = new ArrayList<>();
LinkedList<String> list = new LinkedList<>();
// 添加元素
list.add("zhangsan");
list.add("lisi");
list.add("wangwu");
// 从集合中取出某个元素
// List集合有下标
String firstElt = list.get(0);
System.out.println(firstElt);
// 遍历（下标方式）
for(int i = 0; i < list.size(); i++){
String elt = list.get(i);
System.out.println(elt);
}
// 遍历（迭代器方式，这个是通用的，所有Collection都能用）
Iterator<String> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
// while循环修改为for循环
/*for(Iterator<String> it2 = list.iterator(); it2.hasNext(); ){
System.out.println("====>" + it2.next());
}*/
// 遍历（foreach方式）
for(String s : list){
System.out.println(s);==HashSet==
public class HashSetTest {
public static void main(String[] args) {
// 创建集合对象
HashSet<String> set = new HashSet<>();
// 添加元素
set.add("abc");
set.add("def");
set.add("king");
// set集合中的元素不能通过下标取了。没有下标
// 遍历集合（迭代器）
Iterator<String> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
// 遍历集合（foreach）
for(String s : set){
System.out.println(s);
}
set.add("king");
set.add("king");
set.add("king");
System.out.println(set.size()); //3 （后面3个king都没有加进去。）
set.add("1");
set.add("10");
set.add("2");
for(String s : set){
System.out.println("--->" + s);
}
// 创建Set集合，存储Student数据
Set<Student> students = new HashSet<>();
Student s1 = new Student(111, "zhangsan");
Student s2 = new Student(222, "lisi");
Student s3 = new Student(111, "zhangsan");
students.add(s1);
students.add(s2);
students.add(s3);
System.out.println(students.size()); // 2
// 遍历
for(Student stu : students){
System.out.println(stu);
}
}
}
class Student {
int no;
String name;
public Student() {
}
public Student(int no, String name) {
this.no = no;
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return no == student.no &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(no, name);
}
}==hashmap==
// 创建Map集合
Map<Integer, String> map = new HashMap<>();
// 添加元素
map.put(1, "zhangsan");
map.put(9, "lisi");
map.put(10, "wangwu");
map.put(2, "king");
map.put(2, "simth"); // key重复value会覆盖。
// 获取元素个数
System.out.println(map.size());
// 取key是2的元素
System.out.println(map.get(2)); // smith
// 遍历Map集合很重要，几种方式都要会。
// 第一种方式：先获取所有的key，遍历key的时候，通过key获取value
Set<Integer> keys = map.keySet();
for(Integer key : keys){
System.out.println(key + "=" + map.get(key));
}
// 第二种方式：是将Map集合转换成Set集合，Set集合中每一个元素是Node
// 这个Node节点中有key和value
Set<Map.Entry<Integer,String>> nodes = map.entrySet();
for(Map.Entry<Integer,String> node : nodes){
System.out.println(node.getKey() + "=" + node.getValue());
}==properties==
// 创建对象
Properties pro = new Properties();
// 存
pro.setProperty("username", "test");
pro.setProperty("password", "test123");
// 取
String username = pro.getProperty("username");
String password = pro.getProperty("password");
System.out.println(username);
System.out.println(password);==TreeSet==
这个比较特殊
public class TreeSetTest {
public static void main(String[] args) {
// 集合的创建（可以测试以下TreeSet集合中存储String、Integer的。这些类都是SUN写好的。）
//TreeSet<Integer> ts = new TreeSet<>();
// 编写比较器可以改变规则。
TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1; // 自动拆箱
}
});
// 添加元素
ts.add(1);
ts.add(100);
ts.add(10);
ts.add(10);
ts.add(10);
ts.add(10);
ts.add(0);
// 遍历（迭代器方式）
Iterator<Integer> it = ts.iterator();
while(it.hasNext()) {
Integer i = it.next();
System.out.println(i);
}
// 遍历（foreach）
for(Integer x : ts){
System.out.println(x);
}
// TreeSet集合中存储自定义类型
TreeSet<A> atree = new TreeSet<>();
atree.add(new A(100));
atree.add(new A(200));
atree.add(new A(500));
atree.add(new A(300));
atree.add(new A(400));
atree.add(new A(1000));
// 遍历
for(A a : atree){
System.out.println(a);
}
//TreeSet<B> btree = new TreeSet<>(new BComparator());
// 匿名内部类方式。
TreeSet<B> btree = new TreeSet<>(new Comparator<B>() {
@Override
public int compare(B o1, B o2) {
return o1.i - o2.i;
}
});
btree.add(new B(500));
btree.add(new B(100));
btree.add(new B(200));
btree.add(new B(600));
btree.add(new B(300));
btree.add(new B(50));
for(B b : btree){
System.out.println(b);
}
}
}
// 第一种方式：实现Comparable接口
class A implements Comparable<A>{
int i;
public A(int i){
this.i = i;
}
@Override
public String toString() {
return "A{" +
"i=" + i +
'}';
}
@Override
public int compareTo(A o) {
//return this.i - o.i;
return o.i - this.i;
}
}
class B {
int i;
public B(int i){
this.i = i;
}
@Override
public String toString() {
return "B{" +
"i=" + i +
'}';
}
}
// 比较器
class BComparator implements Comparator<B> {
@Override
public int compare(B o1, B o2) {
return o1.i - o2.i;
}
}6. IO
I : Input
O : Output
通过IO可以完成硬盘文件的读和写
==流的分类：==
一种方式是按照流的方向进行分类：以内存作为参照物，往内存中去，叫做输入(Input)。或者叫做读(Read)。从内存中出来，叫做输出(Output)。或者叫做写(Write)。
另一种方式是按照读取数据方式不同进行分类：按照字节的方式读取数据，按照字符的方式读取数据的
- java.io.InputStream 字节输入流
- java.io.OutputStream 字节输出流
- java.io.Reader 字符输入流
- java.io.Writer 字符输出流
以上都是都是抽象类。(abstract class)，所有的流都实现java.io.Closeable接口，都是可关闭的，都有close()方法。所有的输出流都实现java.io.Flushable接口，都是可刷新的，都有flush()方法，这个刷新表示将通道/管道当中剩余未输出的数据强行输出完（清空管道！）刷新的作用就是清空管道。注意：如果没有flush()可能会导致丢失数据
文件专属：
java.io.FileInputStream（掌握）
java.io.FileOutputStream（掌握）
java.io.FileReader
java.io.FileWriter
转换流：（将字节流转换成字符流）
java.io.InputStreamReader
java.io.OutputStreamWriter
缓冲流专属：
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream
数据流专属：
java.io.DataInputStream
java.io.DataOutputStream
标准输出流：
java.io.PrintWriter
java.io.PrintStream（掌握）
对象专属流：
java.io.ObjectInputStream（掌握）
java.io.ObjectOutputStream（掌握）==只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流==
6.1 FileInputStream
采用这种int readData = fis.read(); 一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费，读取文件路径的时候使用绝对路径，（IDEA会自动把\编程\，因为java中\表示转义，也可以使用/）
案例如下：
public class FileInputStreamTest02 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("D:\\temp");
/*while(true) {
int readData = fis.read();
if(readData == -1) {
break;
}
System.out.println(readData);
}*/
// 改造while循环
int readData = 0;
while((readData = fis.read()) != -1){
System.out.println(readData);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}为了改进一次只读取一个数据
可以使用一次最多读取 b.length 个字节。减少硬盘和内存的交互，提高程序的执行效率。往byte[]数组当中读。
相对路径在工程Project的根就是IDEA的默认当前路径
// 开始读，采用byte数组，一次读取多个字节。最多读取“数组.length”个字节。
byte[] bytes = new byte[4]; // 准备一个4个长度的byte数组，一次最多读取4个字节。
// 这个方法的返回值是：读取到的字节数量。（不是字节本身）
int readCount = fis.read(bytes);
System.out.println(readCount); // 第一次读到了4个字节。
// 将字节数组全部转换成字符串
//System.out.println(new String(bytes)); // abcd
// 不应该全部都转换，应该是读取了多少个字节，转换多少个。
System.out.println(new String(bytes,0, readCount));
readCount = fis.read(bytes); // 第二次只能读取到2个字节。
System.out.println(readCount); // 2
// 将字节数组全部转换成字符串
//System.out.println(new String(bytes)); // efcd
// 不应该全部都转换，应该是读取了多少个字节，转换多少个。
System.out.println(new String(bytes,0, readCount));
readCount = fis.read(bytes); // 1个字节都没有读取到返回-1
System.out.println(readCount); // -1为了改进上面这种算法采用有多少读取多少
FileInputStream fis = null;
try {
fis = new FileInputStream("chapter23/src/tempfile3");
// 准备一个byte数组
byte[] bytes = new byte[4];
/*while(true){
int readCount = fis.read(bytes);
if(readCount == -1){
break;
}
// 把byte数组转换成字符串，读到多少个转换多少个。
System.out.print(new String(bytes, 0, readCount));
}*/
int readCount = 0;
while((readCount = fis.read(bytes)) != -1) {
System.out.print(new String(bytes, 0, readCount));
}==模板==
byte[] bytes = new byte[4];
int readCount = 0;
while((readCount = fis.read(bytes)) != -1) {
System.out.print(new String(bytes, 0, readCount));
}==其他常用方法==
| 方法 | 功能 |
|---|---|
| int available() | 返回流当中剩余的没有读到的字节数量 |
| long skip(long n) | 跳过几个字节不读 |
这些方法的具体使用如下
主要是一次性获取
不太适合太大的文件，因为byte[]数组不能太大。
byte[] bytes = new byte[fis.available()];
int readCount = fis.read(bytes); // 6
System.out.println(new String(bytes)); // abcdef
// skip跳过几个字节不读取，这个方法也可能以后会用！
fis.skip(3);
System.out.println(fis.read()); //1006.2 FileOutputStream
myfile文件不存在的时候会自动新建fos = new FileOutputStream("myfile");
如果没有true追加的形式，则会直接覆盖掉原来的东西
// 以追加的方式在文件末尾写入。不会清空原文件内容。
fos = new FileOutputStream("chapter23/src/tempfile3", true);
// 开始写。
byte[] bytes = {97, 98, 99, 100};
// 将byte数组全部写出！
fos.write(bytes); // abcd
// 将byte数组的一部分写出！
fos.write(bytes, 0, 2); // 再写出ab将字符串转换为byte数组，进行写入
// 字符串
String s = "我是一个中国人，我骄傲！！！";
// 将字符串转换成byte数组。
byte[] bs = s.getBytes();
// 写
fos.write(bs);每一次的写入都要记得刷新fos.flush();
而且在finally之后要关闭
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}6.3 FileReader
文件字符输入流，只能读取普通文本。
读取文本内容时，比较方便，快捷。
主要的核心代码如下
==读取指定的单一字符遍历输出：==
//准备一个char数组
char[] chars = new char[4];
// 往char数组中读
reader.read(chars); // 按照字符的方式读取：第一次e，第二次f，第三次 风....
for(char c : chars) {
System.out.println(c);
}或者是根据文件获取的字符数一直while，比较方便，当为-1的时候结束输出
// 开始读
char[] chars = new char[4]; // 一次读取4个字符
int readCount = 0;
while((readCount = reader.read(chars)) != -1) {
System.out.print(new String(chars,0,readCount));
}6.4 FileReader
FileWriter:
文件字符输出流。写。只能输出普通文本。
核心代码如下：
追加与不追加，覆盖的区别
// 创建文件字符输出流对象
//out = new FileWriter("file");
out = new FileWriter("file", true);书写的核心文件如下
// 开始写。
char[] chars = {'我','是','中','国','人'};
out.write(chars);
out.write(chars, 2, 3);也可以单独输出一个字符串
out.write("我是一名java软件工程师！");
// 写出一个换行符。
out.write("\n");
out.write("hello world!");每一次的写入都要记得刷新fos.flush();
而且在finally之后要关闭
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}6.5 文件复制
==字节流的文件复制==
使用FileInputStream + FileOutputStream完成文件的拷贝。
拷贝的过程应该是一边读，一边写。
使用以上的字节流拷贝文件的时候，文件类型随意，万能的。什么样的文件都能拷贝。
完整代码如下，==模板==
public class Copy01 {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
// 创建一个输入流对象
fis = new FileInputStream("");
// 创建一个输出流对象
fos = new FileOutputStream("");
// 最核心的：一边读，一边写
byte[] bytes = new byte[1024 * 1024]; // 1MB（一次最多拷贝1MB。）
int readCount = 0;
while((readCount = fis.read(bytes)) != -1) {
fos.write(bytes, 0, readCount);
}
// 刷新，输出流最后要刷新
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 分开try，不要一起try。
// 一起try的时候，其中一个出现异常，可能会影响到另一个流的关闭。
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}注意区分两者的不同
==字符流的文件复制==
使用FileReader FileWriter进行拷贝的话，只能拷贝“普通文本”文件。
完整代码如下
public class Copy02 {
public static void main(String[] args) {
FileReader in = null;
FileWriter out = null;
try {
// 读
in = new FileReader("chapter23/src/com/bjpowernode/java/io/Copy02.java");
// 写
out = new FileWriter("Copy02.java");
// 一边读一边写：
char[] chars = new char[1024 * 512]; // 1MB
int readCount = 0;
while((readCount = in.read(chars)) != -1){
out.write(chars, 0, readCount);
}
// 刷新
out.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}6.6 带缓冲区字符流
6.6.1 BufferedReader
==带有缓冲区的字符输入流==
通过这个 BufferedReader br = new BufferedReader(reader);本身这个函数内部是不可以使用reader的，因为是抽象类，必须要找抽象类的实现类，所以在这之前要 FileReader reader = new FileReader("Copy02.java");
当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流。外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流。
像当前这个程序来说：FileReader就是一个节点流。BufferedReader就是包装流/处理流。
关闭的时候只需要关闭外层流就可，因为内部流in会自动关闭
具体的测试文件如下
FileReader reader = new FileReader("Copy02.java");
BufferedReader br = new BufferedReader(reader);
// 读一行
String firstLine = br.readLine();
System.out.println(firstLine);
// br.readLine()方法读取一个文本行，但不带换行符。
String s = null;
while((s = br.readLine()) != null){
System.out.println(s);
}
// 关闭流
// 对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭。（可以看源代码。）
br.close();如果传输的是字节流，需要将字节流转换为字符流使用InputStreamReader
具体测试代码如下
FileInputStream in = new FileInputStream("Copy02.java");
// 通过转换流转换（InputStreamReader将字节流转换成字符流。）
// in是节点流。reader是包装流。
InputStreamReader reader = new InputStreamReader(in);
// 这个构造方法只能传一个字符流。不能传字节流。
BufferedReader br = new BufferedReader(reader);*/
// 合并
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("Copy02.java")));
String line = null;
while((line = br.readLine()) != null){
System.out.println(line);
}
// 关闭最外层
br.close();6.6.1 BufferedWriter
只要是写的，都要在后面记得刷新
带有缓冲区的字符输出流
//BufferedWriter out = new BufferedWriter(new FileWriter("copy"));
// 开始写。
out.write("hello world!");
out.write("\n");
out.write("hello kitty!");
// 刷新
out.flush();
// 关闭最外层
out.close();如果是带有字节流的，可以将其转换为字符流true为追加文件末尾而不是覆盖
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("copy", true)));6.7 数据流
==字节数据输出流==
java.io.DataOutputStream：数据专属的流。
这个流可以将数据连同数据的类型一并写入文件。
注意：这个文件不是普通文本文档。（这个文件使用记事本打不开。）
// 创建数据专属的字节输出流
本身是接口类，不可以直接new，必须接一个接口实现类
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));比如测试代码如下
// 写数据
byte b = 100;
short s = 200;
int i = 300;
long l = 400L;
float f = 3.0F;
double d = 3.14;
boolean sex = false;
char c = 'a';
// 写
dos.writeByte(b); // 把数据以及数据的类型一并写入到文件当中。
dos.writeShort(s);
dos.writeInt(i);
dos.writeLong(l);
dos.writeFloat(f);
dos.writeDouble(d);
dos.writeBoolean(sex);
dos.writeChar(c);
// 刷新
dos.flush();
// 关闭最外层
dos.close();==字节数据输入流==
DataInputStream:数据字节输入流。
DataOutputStream写的文件，只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。
读的顺序需要和写的顺序一致。才可以正常取出数据。
测试文件同理如下
DataInputStream dis = new DataInputStream(new FileInputStream("data"));
// 开始读
byte b = dis.readByte();
short s = dis.readShort();
int i = dis.readInt();
long l = dis.readLong();
float f = dis.readFloat();
double d = dis.readDouble();
boolean sex = dis.readBoolean();
char c = dis.readChar();
System.out.println(b);
System.out.println(s);
System.out.println(i + 1000);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(sex);
System.out.println(c);
dis.close();6.8 File
- File类不能完成文件的读和写。
- 一个File对象有可能对应的是目录，也可能是文件。
File只是一个路径名的抽象表示形式。创建一个File对象
File f1 = new File("D:\\file");判断是否存在！
System.out.println(f1.exists());// 如果D:\file不存在，则以文件的形式创建出来
if(!f1.exists()) {
// 以文件形式新建
f1.createNewFile();
}
// 如果D:\file不存在，则以目录的形式创建出来
if(!f1.exists()) {
// 以目录的形式新建。
f1.mkdir();
}
// 可以创建多重目录吗？
File f2 = new File("D:/a/b/c/d/e/f");
if(!f2.exists()) {
// 多重目录的形式新建。
f2.mkdirs();
}
File f3 = new File("D:\\course\\01-开课\\学习方法.txt");
// 获取文件的父路径
String parentPath = f3.getParent();
System.out.println(parentPath); //D:\course\01-开课
File parentFile = f3.getParentFile();
System.out.println("获取绝对路径：" + parentFile.getAbsolutePath());
File f4 = new File("copy");
System.out.println("绝对路径：" + f4.getAbsolutePath()); // C:\Users\Administrator\IdeaProjects\javase\copy==常用方法==
示例代码
File f1 = new File("D:\\course\\01-开课\\开学典礼.ppt");
// 获取文件名
System.out.println("文件名：" + f1.getName());
// 判断是否是一个目录
System.out.println(f1.isDirectory()); // false
// 判断是否是一个文件
System.out.println(f1.isFile()); // true
// 获取文件最后一次修改时间
long haoMiao = f1.lastModified(); // 这个毫秒是从1970年到现在的总毫秒数。
// 将总毫秒数转换成日期?????
Date time = new Date(haoMiao);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
String strTime = sdf.format(time);
System.out.println(strTime);
// 获取文件大小
System.out.println(f1.length()); //216064字节。==获取所有子文件==
使用File中的listFiles方法
使用 File[] 数组来接收
// File[] listFiles()
// 获取当前目录下所有的子文件。
File f = new File("D:\\course\\01-开课");
File[] files = f.listFiles();
// foreach
for(File file : files){
//System.out.println(file.getAbsolutePath());
System.out.println(file.getName());6.9 拷贝目录文件
- 判断是否为其文件，如果是文件则一边读一边写传输数据
- 判断是否为其目录，如果是目录，再根据其子目录进行传输遍历
/*
拷贝目录
*/
public class CopyAll {
public static void main(String[] args) {
// 拷贝源
File srcFile = new File("D:\\course\\02-JavaSE\\document");
// 拷贝目标
File destFile = new File("C:\\a\\b\\c");
// 调用方法拷贝
copyDir(srcFile, destFile);
}
/**
* 拷贝目录
* @param srcFile 拷贝源
* @param destFile 拷贝目标
*/
private static void copyDir(File srcFile, File destFile) {
if(srcFile.isFile()) {
// srcFile如果是一个文件的话，递归结束。
// 是文件的时候需要拷贝。
// ....一边读一边写。
FileInputStream in = null;
FileOutputStream out = null;
try {
// 读这个文件
// D:\course\02-JavaSE\document\JavaSE进阶讲义\JavaSE进阶-01-面向对象.pdf
in = new FileInputStream(srcFile);
// 写到这个文件中
// C:\course\02-JavaSE\document\JavaSE进阶讲义\JavaSE进阶-01-面向对象.pdf
String path = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\") + srcFile.getAbsolutePath().substring(3);
out = new FileOutputStream(path);
// 一边读一边写
byte[] bytes = new byte[1024 * 1024]; // 一次复制1MB
int readCount = 0;
while((readCount = in.read(bytes)) != -1){
out.write(bytes, 0, readCount);
}
out.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return;
}
// 获取源下面的子目录
File[] files = srcFile.listFiles();
for(File file : files){
// 获取所有文件的（包括目录和文件）绝对路径
//System.out.println(file.getAbsolutePath());
if(file.isDirectory()){
// 新建对应的目录
//System.out.println(file.getAbsolutePath());
//D:\course\02-JavaSE\document\JavaSE进阶讲义 源目录
//C:\course\02-JavaSE\document\JavaSE进阶讲义 目标目录
String srcDir = file.getAbsolutePath();
String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\") + srcDir.substring(3);
File newFile = new File(destDir);
if(!newFile.exists()){
newFile.mkdirs();
}
}
// 递归调用
copyDir(file, destFile);
}
}
}6.10 IO+properties
经常改变的数据，可以单独写到一个文件中，使用程序动态读取
将来只需要修改这个文件的内容，java代码不需要改动，不需要重新编译，服务器也不需要重启。就可以拿到动态的信息
配置文件中的内容格式是：
key1=value
key2=value
属性配置文件建议以.properties结尾，但这不是必须的。
这种以.properties结尾的文件在java中被称为：属性配置文件。
其中Properties是专门存放属性配置文件内容的一个类
主要的代码思路是
新建一个输入流对象
创建一个集合，运用结合中的load方法将其输入流对象加载到集合中
之后运用集合的key与value进行获取
public class IoPropertiesTest01 {
public static void main(String[] args) throws Exception{
/*
Properties是一个Map集合，key和value都是String类型。
想将userinfo文件中的数据加载到Properties对象当中。
*/
// 新建一个输入流对象
FileReader reader = new FileReader("chapter23/userinfo.properties");
// 新建一个Map集合
Properties pro = new Properties();
// 调用Properties对象的load方法将文件中的数据加载到Map集合中。
pro.load(reader); // 文件中的数据顺着管道加载到Map集合中，其中等号=左边做key，右边做value
// 通过key来获取value呢？
String username = pro.getProperty("username");
System.out.println(username);
String password = pro.getProperty("password");
System.out.println(password);
}
}配置文件
username=admin
password=4564567. 序列化与反序列化
具体这部分知识可看我之前的文章
java之序列化与反序列化的详细解析（全）
