Collection集合重难点梳理,增强for注意事项和三种遍历的应用场景,栈和队列特点,数组和链表特点,ArrayList源码解析, LinkedList-源码解析
重难点梳理
使用到的新单词:
1.collection[kəˈlekʃn]
聚集
2.empty[ˈempti]
空的
3.clear[klɪə(r)]
清除
4.iterator
迭代器
学习目标:
1、能够了解Java集合的继承体系结构（Collection和Map接口的继承体系结构）
2、能够了解Collection集合特点以及使用
3、能够掌握List集合的特点以及使用
4、能够掌握ArrayList集合特点以及使用（特点，使用以及原理）
5、能够掌握常见数据结构的特点（栈，队列，数组，链表）
知识重点梳理
超详细讲义及源代码
==知识点==
集合概述
Collection
List
数据结构
ArrayList
LinkedList
1.Collection集合
1.1数组和集合的对比【记忆】(视频01)（6‘’）
相同点
都是容器,可以存储多个数据
不同点
数组的长度是不可变的,集合的长度是可变的
数组可以存基本数据类型和引用数据类型
集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Arrays;
public class MyCollectonDemo1 {
public static void main(String[] args) {
//数组可以存储基本数据类型也可以存储引用数据类型
int [] arr1 = {1,2,3};
String [] arr2 = {"a","b","c"};
System.out.println(Arrays.toString(arr1));
System.out.println(Arrays.toString(arr2));
ArrayList<String> list1 = new ArrayList<>();
list1.add("a");
list1.add("b");
list1.add("c");
System.out.println(list1);
//如果集合要存储基本数据类型,那么实际存储的是他们的包装类
//ArrayList<int> list2 = new ArrayList<int>();
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(1);//
list2.add(2);
list2.add(3);
System.out.println(list2);
}
}
1.2集合类体系结构【熟悉】(视频02)(换双列) （3‘’）
1.3Collection 常用方法【重点】(视频03) （13‘’）
1.什么是Collection集合(顶级接口和特点单列)
Collection是单列集合的顶级接口，它没有直接的具体实现类，有两个子接口List和Set
2.如何创建Collection集合对象（Collection和ArrayList的关系）
多态的方式
具体的实现类ArrayList
3.Collection集合常用方法
| 方法名 | 说明 |
|---|---|
| boolean add(E e) | 添加元素 |
| boolean remove(Object o) | 从集合中移除指定的元素 |
| boolean removeIf(Object o) | 根据条件进行移除 |
| void clear() | 清空集合中的元素 |
| boolean contains(Object o) | 判断集合中是否存在指定的元素 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中元素的个数 |
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Collection;
public class MyCollectonDemo2 {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
// boolean add(E e) 添加元素
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
collection.add("dddd");
//System.out.println(collection);
//method1(collection);
//method2(collection);
//method3(collection);
//method4(collection);
//method5(collection);
//method6(collection);
}
private static void method6(Collection<String> collection) {
// int size() 集合的长度，也就是集合中元素的个数
int size = collection.size();
System.out.println(size);
}
private static void method5(Collection<String> collection) {
// boolean isEmpty() 判断集合是否为空
collection.clear();
boolean result = collection.isEmpty();
System.out.println(result);
}
private static void method4(Collection<String> collection) {
// boolean contains(Object o) 判断集合中是否存在指定的元素
boolean result = collection.contains("a");
System.out.println(result);
boolean result2 = collection.contains("aaa");
System.out.println(result2);
}
private static void method3(Collection<String> collection) {
// void clear() 清空集合
//就是将集合中所有的元素全部删除.
collection.clear();
System.out.println(collection);
}
private static void method2(Collection<String> collection) {
// boolean removeif(Object o) 根据条件进行删除
//removeif底层会遍历集合,得到集合中的每一个元素
//s依次表示集合中的每一个元素
//就会把这每一个元素都到lambda表达式中去判断一下
//如果返回的是true,则删除
//如果返回的是false,则保留不删除.
//boolean test(String t);
collection.removeIf(
(String s)->{
return s.length() == 3;
}
);
System.out.println(collection);
}
private static void method1(Collection<String> collection) {
// boolean remove(Object o) 从集合中移除指定的元素
//如果删除成功了,则返回true
//如果删除失败了,则返回false
boolean result1 = collection.remove("aaa");
boolean result2 = collection.remove("ddd");
System.out.println(result1);
System.out.println(result2);
System.out.println(collection);
}
}
1.4Collection-迭代器的基本使用【重点】（视频04 7‘’）
迭代器 的作用
用于集合的遍历（迭代器就是一个对象）
2.如何创建迭代器
Iterator<E> iterator(): 返回此集合中元素的迭代器,该迭代器器对象默认指向当前集合0索引
3.Iterator中的常用方法
boolean hasNext(): 判断当前位置是否有元素可以被取出 E next(): 获取当前位置的元素,同时将迭代器对象移向下一个索引位置
4.Collection集合的遍历
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class MyCollectonDemo3 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//1,获得迭代器的对象
//迭代器对象一旦被创建出来,默认指向集合的0索引处
Iterator<String> it = list.iterator();
//利用迭代器里面的方法进行遍历
//当前位置是否有元素可以被取出
// System.out.println(it.hasNext());
// //取出当前位置的元素 + 将迭代器往后移动一个索引的位置
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
while(it.hasNext()){
System.out.println(it.next());
}
}
}
1.5 迭代器的原理分析【重点、难点】（视频05）（5‘’）
迭代器原理(三个方法) ①. Iterator<E> iterator(): 获取迭代器对象,默认指向0索引 ②. boolean hasNext():判断当前位置是否有元素可以被取出 ③. E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
while(it.hasNext()){
System.out.println(it.next());
}
1.6 迭代器中删除的方法【重点】(视频06) （8‘’）
void remove(): 删除迭代器对象当前指向的元素
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Iterator;
public class MyCollectonDemo5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
if("b".equals(s)){
//指向谁,那么此时就删除谁.
it.remove();
}
}
System.out.println(list);
}
}
1.7 增强for循环-基本应用【重点】（视频07）（6‘’）
1.增强for的作用
简化数组和Collection集合的遍历,比迭代器简单也比for循环也简单
2.如何使用？
for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}
3.增强for的原理
它是JDK5之后出现的,其内部原理是一个Iterator迭代器(数组是for，集合为Iterator)
4.增强for的应用场景
实现Iterable接口的类才可以使用迭代器和增强for(数组)
代码
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
public class MyCollectonDemo6 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
//1,数据类型一定是集合或者数组中元素的类型
//2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
//3,list就是要遍历的集合或者数组.
for(String str : list){
System.out.println(str);
}
}
}
1.8 增强for-注意事项和三种遍历的应用场景【记忆】(视频08)（4‘’）
1.注意事项
在增强for循环中无法改变数组或集合中的元素（iterator）
2.三种遍历方式使用场景 增强for: 对集合进行只要简单遍历时使用 普通for: 遍历过程中需要操作索引时使用 迭代器: 遍历过程中需要删除元素时使用
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
public class MyCollectonDemo7 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//
// for(String str : list){
// str = "q";
// System.out.println(str);
// }
for (String s : list) {
System.out.println(s);
}
//System.out.println(list);
}
}
1.9 Collection练习【重点】（视频9）(4'')
注意：增强for可以操作数组和集合，而迭代器只能操作集合
package com.itheima.mycollectiondemo1;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Iterator;
public class MyCollectonDemo8 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student s1 = new Student("小皮同学",23);
Student s2 = new Student("小路同学",31);
Student s3 = new Student("小贾同学",33);
list.add(s1);
list.add(s2);
list.add(s3);
//迭代器的方式进行遍历
Iterator<Student> it = list.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.println(s);
}
System.out.println("-------------------------");
//增强for
for (Student student : list) {
System.out.println(student);
}
}
}
2.List集合
2.1List集合的概述和特点【记忆】(视频10) （4‘’）
List集合的特点
存取有序
可以重复
有索引
package com.itheima.mylistdemo1;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class MyListDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("---------------------");
for (String s : list) {
System.out.println(s);
}
}
}
2.2List集合的特有方法【重点】(视频11) （7‘’）
方法介绍
方法名 描述 void add(int index,E element) 在此集合中的指定位置插入指定的元素 E remove(int index) 删除指定索引处的元素，返回被删除的元素 E set(int index,E element) 修改指定索引处的元素，返回被修改的元素 E get(int index) 返回指定索引处的元素 示例代码
package com.itheima.mylistdemo1;
import java.util.ArrayList;
import java.util.List;
public class MyListDemo2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//method1(list);
//method2(list);
//method3(list);
//method4(list);
}
private static void method4(List<String> list) {
// E get(int index) 返回指定索引处的元素
String s = list.get(0);
System.out.println(s);
}
private static void method3(List<String> list) {
// E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
//被替换的那个元素,在集合中就不存在了.
String result = list.set(0, "qqq");
System.out.println(result);
System.out.println(list);
}
private static void method2(List<String> list) {
// E remove(int index) 删除指定索引处的元素，返回被删除的元素
//在List集合中有两个删除的方法
//第一个 删除指定的元素,返回值表示当前元素是否删除成功
//第二个 删除指定索引的元素,返回值表示实际删除的元素
String s = list.remove(0);
System.out.println(s);
System.out.println(list);
}
private static void method1(List<String> list) {
// void add(int index,E element) 在此集合中的指定位置插入指定的元素
//原来位置上的元素往后挪一个索引.
list.add(0,"qqq");
System.out.println(list);
}
}
3.数据结构
3.1数据结构之栈和队列【记忆】（视频12）（6‘’）
栈结构
先进后出
队列结构
先进先出
3.2数据结构之数组和链表【记忆】(视频13) （11‘’）
数组结构（内存，下标）
数组的特点
查询快、增删慢
链表结构（内存,下标）
什么是链表
链表的特点
查询慢、增删快
4.ArrayList源码解析【难点】（视频14）（16‘’）
1.ArrayList底层是一个数组
2.当初始化ArrayList，数组的长度为0
3.当第一次添加的时候，数组的长度为10
4.以后添加时，如果数组的长度不满足时，进行扩容 ，按1.5来进行扩容
5.扩容之后，将原数组中的元素拷贝到新的数组中
5.List集合的实现类
5.1LinkedList-基本应用【记忆】(视频15) （3‘’）
ArrayList集合的特点(加塞儿代码验证1万次)
底层是数组结构实现，查询快、增删慢
LinkedList集合特点
底层是链表结构实现，查询慢、增删快
比较添加
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
ArrayList<Integer> array=new ArrayList<>();
LocalDateTime arrayStartTime = LocalDateTime.now();
for (int i=0;i<100000;i++){
array.add(0,i);
}
LocalDateTime arrayEndTime = LocalDateTime.now();
Duration duration = Duration.between(arrayStartTime, arrayEndTime);
System.out.println(duration.toNanos());
LocalDateTime linkStartTime = LocalDateTime.now();
for (int i=0;i<100000;i++){
list.add(0,i);
}
LocalDateTime linkEndTime = LocalDateTime.now();
Duration duration1 = Duration.between(linkStartTime, linkEndTime);
System.out.println(duration1.toNanos());
}
package com.itheima.mylistdemo1;
import java.util.Iterator;
import java.util.LinkedList;
public class MyLinkedListDemo3 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("-------------------------");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("--------------------------");
for (String s : list) {
System.out.println(s);
}
}
}
5.2LinkedList集合的特有功能【重点】(视频16) （5‘’）
特有方法
方法名 说明 public void addFirst(E e) 在该列表开头插入指定的元素 public void addLast(E e) 将指定的元素追加到此列表的末尾 public E getFirst() 返回此列表中的第一个元素 public E getLast() 返回此列表中的最后一个元素 public E removeFirst() 从此列表中删除并返回第一个元素 public E removeLast() 从此列表中删除并返回最后一个元素 示例代码
package com.itheima.mylistdemo1;
import java.util.LinkedList;
public class MyLinkedListDemo4 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// public void addFirst•(E e) 在该列表开头插入指定的元素
//method1(list);
// public void addLast•(E e) 将指定的元素追加到此列表的末尾
//method2(list);
// public E getFirst•() 返回此列表中的第一个元素
// public E getLast•() 返回此列表中的最后一个元素
//method3(list);
// public E removeFirst•() 从此列表中删除并返回第一个元素
// public E removeLast•() 从此列表中删除并返回最后一个元素
//method4(list);
}
private static void method4(LinkedList<String> list) {
String first = list.removeFirst();
System.out.println(first);
String last = list.removeLast();
System.out.println(last);
System.out.println(list);
}
private static void method3(LinkedList<String> list) {
String first = list.getFirst();
String last = list.getLast();
System.out.println(first);
System.out.println(last);
}
private static void method2(LinkedList<String> list) {
list.addLast("www");
System.out.println(list);
}
private static void method1(LinkedList<String> list) {
list.addFirst("qqq");
System.out.println(list);
}
}
5.3 LinkedList-源码解析【难点】 (视频17) （13‘’）
1.add方法解析：
1.new LinkedList
2.list.add("aaa")
3.list.add("bbb")
4.list.add("ccc")
2.get方法解析：
get(Index) 首先判断索引离头近还是离尾近，如果离头从头查，如果离尾近从尾查
扩展练习
问答题【Collection接口】
1.1 请问Collection接口下有哪些类型的集合？它们分别是什么？
List 有序,有索引,元素可重复
Set 元素不可重复;
1.2 请问Collection接口中定义的方法，它的所有子类是否都有，而且都会实现这些方法？
是
1.3 请问向Collection集合添加一个元素用什么方法？
类名.add(元素)
1.4 请问从Collection集合中删除一个元素用什么方法？这个方法有返回值吗？
类名.remove(元素)返回true/fasle
1.5 请问判断Collection集合中是否包含一个元素用什么方法？
contains(),判断集合是否存在元素
1.6 请问用什么方法可以获取Collection集合中元素的数量？
类名.size
问答题【数据结构】
1 请写出数组结构的特点；
查看快,增加删除慢
2 请写出链表结构的特点
查看慢,增加删除快
3 请写出栈结构的特点；
先进后出
4 请写出队列结构的特点；
先进先出
编程题【Collection集合、迭代器】
题目1
请定义一个Collection类型的集合，存储以下字符串： “JavaEE企业级开发指南”，”Oracle高级编程”，”MySQL从入门到精通”，”Java架构师之路” 要求: 请编程实现以下功能： 使用迭代器遍历所有元素，并打印 使用迭代器遍历所有元素，筛选书名小于10个字符的，并打印； 使用迭代器遍历所有元素，筛选书名中包含“Java”的，并打印 如果书名中包含“Oracle”，则删掉此书。删掉后，遍历集合，打印所有书名。 (注意：以上每个功能都单独写个方法，在main方法中逐个调用测试即可)
效果:
参考代码:
package day7.No_1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("JavaEE企业级开发指南");
list.add("Oracle高级编程");
list.add("MySQL从入门到精通");
list.add("Java架构师之路");
System.out.println("遍历");
Iterator<String> it = list.iterator();
System.out.println("遍历为:");
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
System.out.println("-----------");
Iterator<String> it2 = list.iterator();
System.out.println("长度小于10的为:");
while (it2.hasNext()) {
String s = it2.next();
if (s.length() < 10) {
System.out.println( s);
}
}
System.out.println("-----------");
Iterator<String> it1 = list.iterator();
System.out.println("包含Java为:");
while (it1.hasNext()){
String s = it1.next();
if (s.contains("Java")){
System.out.println(s);
}
}
System.out.println("-----------");
Iterator<String> it3 = list.iterator();
while (it3.hasNext()){
String s = it3.next();
if (s.contains("Oracle")){
it3.remove();
System.out.println("Oracle已成功删除!");
}
}
System.out.println("-----------");
System.out.println("删除后为:"+list);
}
}
运行效果:
题目2
请定义一个Collection类型的集合，存储以下分数信息： 88.5,39.2,77.1,56.8,89.0,99.0,59.5
要求:
请编程实现以下功能： 使用增强for遍历所有元素，并打印 使用增强for遍历所有元素，打印不及格的分数； 使用增强for遍历所有元素，计算不及格的分数的数量，和平均分，并打印计算结果。 使用增强for遍历所有元素，求出最高分，并打印；
效果:
参考代码:
package day7.No_2; import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection; public class Demo {
public static void main(String[] args) {
Collection <Double>list=new ArrayList<>();
list.add(88.5);
list.add(39.2);
list.add(77.1);
list.add(56.8);
list.add(89.0);
list.add(99.0);
list.add(59.5);
System.out.println("增强for遍历所有为:");
for (Double d : list) {
System.out.println(d);
}
System.out.println("不及格的为:");
for (Double d : list) {
if (d<60){
System.out.println(d);
}
}
int sum=0;
int Num=0;
for (Double d : list) {
if (d<60){
Num++;
sum+=d;
}
}
System.out.println("不及格人数为"+Num);
System.out.println("不及格平均分为"+(sum/Num));
System.out.println("-----------");
double max = Double.MIN_VALUE;
for (Double d : list) {
if (d>max){
max=d;
}
}
System.out.println("最高分为:"+max);
}
}
运行效果:
题目3
请定义方法找出集合中所有姓张的人并且年龄大于18岁的并全部返回,然后在main方法中输出返回的人; 集合原始数据有: 张三,22 李四,26 张翠山,38 赵六,19 张三丰,103 张无忌,17 赵敏,16
要求:
集合中的人需要以对象的形式存在,人只要有姓名和年龄两个成员变量即可;
注意:仔细思考一下自定义的方法要不要设计参数和返回值;
效果:
参考代码:
package day7.No_3;
import java.util.ArrayList;
public class Demo {
public static void main(String[] args) {
ArrayList<Ren> list = new ArrayList<>();
Ren r1 = new Ren("张三", 22);
Ren r2 = new Ren("李四", 26);
Ren r3 = new Ren("张翠山", 38);
Ren r4 = new Ren("赵六", 19);
Ren r5 = new Ren("张三丰", 103);
Ren r6 = new Ren("张无忌", 17);
Ren r7 = new Ren("赵敏", 16);
list.add(r1);
list.add(r2);
list.add(r3);
list.add(r4);
list.add(r5);
list.add(r6);
list.add(r7);
get(list);
}
private static void get(ArrayList<Ren> list) {
System.out.println("大于18的人为:");
for (Ren ren : list) {
if (ren.getAge() > 18) {
System.out.println(ren);
}
}
}
}
class Ren {
private String name;
private int age;
@Override
public String toString() {
return "Ren{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
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 Ren(String name, int age) {
this.name = name;
this.age = age;
}
public Ren() {
}
}
Collection集合重难点梳理,增强for注意事项和三种遍历的应用场景,栈和队列特点,数组和链表特点,ArrayList源码解析, LinkedList-源码解析的更多相关文章
- java 15 - 9 集合框架之 栈、队列、数组 和 链表
- Java中List集合的三种遍历方式(全网最详)
List集合在Java日常开发中是必不可少的,只要懂得运用各种各样的方法就可以大大提高我们开发的效率,适当活用各种方法才会使我们开发事半功倍. 我总结了三种List集合的遍历方式,下面一一来介绍. 首 ...
- java 集合之HashMap的三种遍历
HashMap 是一个散列表,它存储的内容是键值对(key-value)映射. 这周我们只需记住三种遍历方法 1.通过keySet()获取键,再利用hashmap里面的.get(key)方法通过键获取 ...
- 大数据学习day13------第三阶段----scala01-----函数式编程。scala以及IDEA的安装，变量的定义，条件表达式，for循环（守卫模式，推导式，可变参数以及三种遍历方式），方法定义，数组以及集合（可变和非可变），数组中常用的方法
具体见第三阶段scala-day01中的文档(scala编程基础---基础语法) 1. 函数式编程(https://www.cnblogs.com/wchukai/p/5651185.html): ...
- java集合的三种遍历方式
import java.util.ArrayList; import java.util.Collection;import java.util.Iterator;public class Home ...
- List带索引的常用方法，以及集合的三种遍历
package cn.learn.collection.List; import com.sun.source.tree.NewArrayTree; import java.util.ArrayLis ...
- Java集合框架Collection(1)ArrayList的三种遍历方法
ArrayList是java最重要的数据结构之一,日常工作中经常用到的就是ArrayList的遍历,经过总结,发现大致有三种,上代码: package com.company; import java ...
- Java数组、集合的三种遍历方式（包懂）
1 for循环 for(int i = 0;i<arr.length;i++){ System.out.print(arr[i]+" "); } 2 foreach循环,这种 ...
- List集合三种遍历方法
List<String> list = new ArrayList<String>();list.add("aaa");list.add("bbb ...
随机推荐
- Trie树总结
Trie,又经常叫前缀树,字典树等等.它有很多变种,如后缀树,Radix Tree/Trie,PATRICIA tree,以及bitwise版本的crit-bit tree.当然很多名字的意义其实有交 ...
- Java基础教程——字节流
IO流 水流 特点 连续性 逝者如斯夫,不舍昼夜: 方向性 一江春水向东流.水往低处流.百川东到海,何时复西归?少壮不努力,老大徒伤悲! 源头尽头 唯有源头活水来:覆水难收 Java里的IO也有这样的 ...
- Java基础教程——File类、Paths类、Files类
File类 File类在java.io包中.io代表input和output,输入和输出. 代表与平台无关的文件和目录. 可以新建.删除.重命名,但不能访问文件内容. File类里的常量: impor ...
- IO模式 select、poll、epoll
阻塞(blocking).非阻塞(non-blocking):最常听到阻塞与非阻塞这两个词就是在函数调用中,比如waitid这个函数,通过NOHANG参数可以把waitid设置为非阻塞的,也就是问询一 ...
- http 文件上传
参考https://www.cnblogs.com/yuwei0911/p/8601542.html
- Fiddler 4 断点调试（修改request请求参数）
1.选中要测试的链接 2然后点击规则的Automatic Breakpoints 的Before Requests 3.重新发送请求找到测试的点链接 最终效果如下
- Python正则表达式处理的组是什么？
在学习正则表达式处理开始阶段,对于匹配对象的group数据没有理解,查了资料进行验证测试,终于理解了. 组其实与组匹配模式相关,就是在匹配的正则表达式中使用小括号"()"括起来的任 ...
- Java面试专题-多线程(3)-原子操作
- 【面试】关于get和post两种方法的不同。
最近在面试题和笔试题中经常会看到这道题,所以打算系统的整理一下. 一般标准的答案是这样的. GET在浏览器回退时是无害的,而POST会再次提交请求(浏览器应该告知用户数据会被重新提交). GET产生的 ...
- clion2020最新安装破解版教程 内含激活码、破解补丁、无限重置时间插件
clion是一款开发C.C++等相关程序的利器,到目前为止已经更新到2020.3版本啦!还没有升级的小伙伴们赶紧升级啦,本文教大家如何安装clion2020.3版本并且破解,此方法亲测100%可以永久 ...