内功心法 -- java.util.LinkedList<E> (7)
写在前面的话：读书破万卷，编码如有神
--------------------------------------------------------------------
下文主要对java.util.LinkedList<E>的10个双端队列操作进行介绍，主要内容包括：
1、LinkedList常用的10个双端队列操作介绍
参考内容：
1、JDK源码(1.7)
--------------------------------------------------------------------
1、LinkedList常用的10个双端队列操作介绍
(1)boolean offerFirst(E e)
功能: 将指定的元素e插入此双端队列的开头
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'boolean offerFirst(E e)'方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
Student stu4 = new Student(4,"oopp",22);
System.out.println("linkedList.offerFirst(stu4):" + linkedList.offerFirst(stu4));
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList.offerFirst(stu4):true
linkedList:[Student [stuId=4, stuName=oopp, stuAge=22], Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
源代码如下:
/*
将指定的元素e插入到此双端队列的开头
*/
public boolean offerFirst(E e) {
//调用内部方法addFirst实现
addFirst(e);
return true;
} /*
将指定的元素e插入到此双端队列的开头
*/
public void addFirst(E e) {
//调用内部方法linkFirst实现
linkFirst(e);
} /*
将指定的元素e插入到此双端队列的开头
*/
private void linkFirst(E e) {
//引用f指向此双端队列的开头
final Node<E> f = first;
//新建一个Node节点
final Node<E> newNode = new Node<>(null, e, f);
//此双端队列对象的first属性指向刚新建的Node节点
first = newNode; //如果此双端队列为空，
//则双端队列对象的last属性也指向刚新建的Node节点
//否则原双端队列的头节点的prev属性指向刚新建的Node节点
if (f == null)
last = newNode;
else
f.prev = newNode;
//双端队列中元素个数加1
size++;
//fast-fail机制加1
modCount++;
}
(2)boolean offerLast(E e)
功能: 将指定的元素e插入此双端队列的尾部
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'boolean offerLast(E e) '方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
Student stu4 = new Student(4,"oopp",22);
System.out.println("linkedList.offerLast(stu4):" + linkedList.offerLast(stu4));
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList.offerLast(stu4):true
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22], Student [stuId=4, stuName=oopp, stuAge=22]]
源代码如下:
/*
将指定的元素e插入到此双端队列的尾部
*/
public boolean offerLast(E e) {
//调用方法addLast实现
addLast(e);
return true;
} /*
将指定的元素e插入到此双端队列的尾部
*/
public void addLast(E e) {
//调用方法linkLast实现
linkLast(e);
} /*
将指定的元素e插入到此双端队列的尾部
*/
void linkLast(E e) {
//将引用l指向此双端队列的尾部
final Node<E> l = last;
//新建一个Node节点
final Node<E> newNode = new Node<>(l, e, null);
//此双端队列对象的last属性指向刚新建的Node节点
last = newNode; //如果此双端队列为空
//则双端队列对象的first属性指向刚新建的Node节点
//否则原双端队列尾部对象的next属性指向刚新建的Node节点
if (l == null)
first = newNode;
else
l.next = newNode;
//双端队列中节点元素个数加1
size++;
//fast-fail机制加1
modCount++;
}
(3)E peekFirst()
功能: 获取，但不移除此双端队列的第一个元素（如果此双端队列为空，则返回 null）
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'E peekFirst() '方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
System.out.println("linkedList.peekFirst():" + linkedList.peekFirst());
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList.peekFirst():Student [stuId=1, stuName=zhangsan, stuAge=20]
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
源代码如下:
/*
获取，但不移除此双端队列的第一个元素
*/
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
(4)E peekLast()
功能: 获取，但不移除此双端队列的最后一个元素（如果此双端队列为空，则返回 null）
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'E peekLast()'方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
System.out.println("linkedList.peekLast():" + linkedList.peekLast());
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList.peekLast():Student [stuId=3, stuName=wangwu, stuAge=22]
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
源代码如下:
/*
获取，但不移除此双端队列的最后一个元素
*/
public E peekLast() {
//引用l指向此双端队列的最后一个元素
final Node<E> l = last;
//返回双端队列最后一个元素
return (l == null) ? null : l.item;
}
(5)E pollFirst()
功能: 获取并移除此双端队列的第一个元素（如果此双端队列为空，则返回 null）
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'E pollFirst()'方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
System.out.println("linkedList.pollFirst():" + linkedList.pollFirst());
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList.pollFirst():Student [stuId=1, stuName=zhangsan, stuAge=20]
linkedList:[Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
源代码如下:
/*
获取并移除此双端队列的第一个元素（如果双端队列为空，则返回null）
*/
public E pollFirst() {
//引用f指向此双端队列的第一个节点元素
final Node<E> f = first;
//返回并移除双端队列的第一个元素
return (f == null) ? null : unlinkFirst(f);
} /*
获取并移除此双端队列的第一个元素
*/
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
//记录双端队列的第一个节点的值
final E element = f.item;
//记录双端队列的第二个节点
final Node<E> next = f.next; //将双端队列的头节点的item、next都设置为null,帮助GC回收
f.item = null;
f.next = null; // help GC //此双端队列对象的first属性指向第二个节点
//如果第二个节点尾null,则设置双端队列对象的last属性为null
//否则设置第二个节点的prev属性为null
first = next;
if (next == null)
last = null;
else
next.prev = null;
//此双端队列中元素个数减1
size--;
//fast-fail机制加1
modCount++;
//返回被删除的节点
return element;
}
(6)E pollLast()
功能: 获取并移除此双端队列的最后一个元素（如果此双端队列为空，则返回 null）
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'E pollLast()'方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
System.out.println("linkedList.pollLast():" + linkedList.pollLast());
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList.pollLast():Student [stuId=3, stuName=wangwu, stuAge=22]
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21]]
源代码如下:
/*
获取并移除此双端队列的最后一个元素(如果此双端队列为空，则返回null)
*/
public E pollLast() {
//引用l指向双端独立的最后一个节点
final Node<E> l = last;
//返回并移除此双端队列的最后一个节点
return (l == null) ? null : unlinkLast(l);
} /*
返回并移除此双端队列的最后一个节点
*/
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
//记录双端队列的最后一个节点的值
final E element = l.item;
//记录双端队列的倒数第二个节点
final Node<E> prev = l.prev; //设置双端队列最后一个节点的item、prev为null,帮助GC回收
l.item = null;
l.prev = null; // help GC //双端队列对象的last属性指向双端队列的倒数第二个节点
last = prev;
//如果双端队列的倒数第二个节点为null
//则双端队列的first属性为null
//否则双端队列的倒数第二个节点的next属性为null
if (prev == null)
first = null;
else
prev.next = null;
//双端队列中的元素个数减1
size--;
//fast-fail机制加1
modCount++;
//返回并移除的节点
return element;
}
(7)void push(E e)
功能: 将一个元素推入此双端队列所表示的堆栈；如果成功，则返回 true
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'void push(E e)'方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
Student stu4 = new Student(4,"xiaohong",22);
linkedList.push(stu4);
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList:[Student [stuId=4, stuName=xiaohong, stuAge=22], Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
源代码如下:
/*
将元素e添加到此双端队列所表示的堆栈中
*/
public void push(E e) {
//调用addFirst方法实现
addFirst(e);
}
(8)E pop()
功能: 从此双端队列所表示的堆栈中弹出一个元素
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'E pop()'方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
System.out.println("linkedList.pop():" + linkedList.pop());
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList.pop():Student [stuId=1, stuName=zhangsan, stuAge=20]
linkedList:[Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
源代码如下:
/*
从此双端队列所表示的堆栈中弹出一个元素
*/
public E pop() {
//调用removeFirst方法实现
return removeFirst();
}
(9)boolean removeFirstOccurrence(Object o)
功能: 从此双端队列移除第一次出现的指定元素
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'boolean removeFirstOccurrence(Object o)'方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
System.out.println("linkedList.removeFirstOccurrence(stu2):" + linkedList.removeFirstOccurrence(stu2));
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList.removeFirstOccurrence(stu2):true
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=3, stuName=wangwu, stuAge=22]]
源代码如下:
/*
从此双端队列移除第一次出现的指定元素o
*/
public boolean removeFirstOccurrence(Object o) {
//调用方法remove实现
return remove(o);
}
(10)boolean removeLastOccurrence(Object o)
功能: 从此双端队列移除最后一次出现的指定元素
示例代码:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*********测试LinkedList的'boolean removeLastOccurrence(Object o)'方法的使用**********/
//创建一个LinkedList对象
LinkedList<Student> linkedList = new LinkedList<Student>();
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu1 = new Student(1,"zhangsan",20);
linkedList.add(stu1);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu2 = new Student(2,"lisi",21);
linkedList.add(stu2);
//创建一个Student对象，并将其添加到LinkedList对象中
Student stu3 = new Student(3,"wangwu",22);
linkedList.add(stu3);
linkedList.add(stu2);
linkedList.add(stu3);
System.out.println("linkedList:" + linkedList);
System.out.println("linkedList.removeLastOccurrence(stu2):" + linkedList.removeLastOccurrence(stu2));
System.out.println("linkedList:" + linkedList);
}
}
运行结果:
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22]]
linkedList.removeLastOccurrence(stu2):true
linkedList:[Student [stuId=1, stuName=zhangsan, stuAge=20], Student [stuId=2, stuName=lisi, stuAge=21], Student [stuId=3, stuName=wangwu, stuAge=22], Student [stuId=3, stuName=wangwu, stuAge=22]]
源代码如下:
/*
从此双端队列移除最后一次出现的指定元素o
*/
public boolean removeLastOccurrence(Object o) {
if (o == null) {
//当元素o为null时
//循环逆序遍历此双端队列，查询值为null的节点
for (Node<E> x = last; x != null; x = x.prev) {
if (x.item == null) {
//移除此节点
unlink(x);
return true;
}
}
} else {
//当元素o不为null时
//循环逆序遍历此双端队列，查询值等于节点o的值的节点
for (Node<E> x = last; x != null; x = x.prev) {
if (o.equals(x.item)) {
//移除此节点
unlink(x);
return true;
}
}
}
return false;
}
--------------------------------------------------------------------
java.util.LinkedList<E>系列文章
java.util.LinkedList<E>(1) java.util.LinkedList<E>(2) java.util.LinkedList<E>(3)
java.util.LinkedList<E>(4) java.util.LinkedList<E>(5) java.util.LinkedList<E>(6)
java.util.LinkedList<E>(7) java.util.LinkedList<E>(8)
--------------------------------------------------------------------
相关知识
java.util.Collection<E> java.util.AbstractCollection<E> java.util.List<E>
java.util.AbstractList<E> java.util.Iterator<E> java.util.ListIterator<E>
Java中的标记接口 迭代器模式 Java中的深拷贝和浅拷贝 java.util.Arrays
java.util.Queue<E> java.util.Deque<E>
内功心法 -- java.util.LinkedList<E> (7)的更多相关文章
- 内功心法 -- java.util.LinkedList<E> (3)
写在前面的话:读书破万卷,编码如有神--------------------------------------------------------------------下文主要对java.util ...
- 内功心法 -- java.util.LinkedList<E> (4)
写在前面的话:读书破万卷,编码如有神--------------------------------------------------------------------下文主要对java.util ...
- 内功心法 -- java.util.LinkedList<E> (5)
写在前面的话:读书破万卷,编码如有神--------------------------------------------------------------------下文主要对java.util ...
- 内功心法 -- java.util.LinkedList<E> (6)
写在前面的话:读书破万卷,编码如有神--------------------------------------------------------------------下文主要对java.util ...
- 内功心法 -- java.util.LinkedList<E> (8)
写在前面的话:读书破万卷,编码如有神--------------------------------------------------------------------下文主要对java.util ...
- 内功心法 -- java.util.LinkedList<E> (1)
写在前面的话:读书破万卷,编码如有神--------------------------------------------------------------------下文主要对java.util ...
- 内功心法 -- java.util.LinkedList<E> (2)
写在前面的话:读书破万卷,编码如有神--------------------------------------------------------------------下文主要对java.util ...
- java.util.ArrayList、java.util.vector和java.util.LinkedList （JDK 1.8.0_111）
一.java.util.ArrayList 1.1 ArrayList 继承结构 ArrayList实现了RandomAccess,可以随机访问(其实就是通过数组下标访问):实现了Cloneable, ...
- JDK1.8源码(六)——java.util.LinkedList 类
上一篇博客我们介绍了List集合的一种典型实现 ArrayList,我们知道 ArrayList 是由数组构成的,本篇博客我们介绍 List 集合的另一种典型实现 LinkedList,这是一个有链表 ...
随机推荐
- Coursera在线学习---第一节.梯度下降法与正规方程法求解模型参数比较
一.梯度下降法 优点:即使特征变量的维度n很大,该方法依然很有效 缺点:1)需要选择学习速率α 2)需要多次迭代 二.正规方程法(Normal Equation) 该方法可以一次性求解参数Θ 优点:1 ...
- layui结合mybatis的pagehelper插件的分页通用的方法
总体思路: 1.前台查询的时候将当前页和页大小传到后台 2.后台将当前页,页大小以及数据与数据总数返回前台,前台显示完表格完数据之后显示分页插件. 前台页面: 准备查询条件的表单,与数据表格,分页di ...
- PHP对象2: 构造函数与析构函数
当一个对象的所有引用都没有时, 一个对象才消失, 这时才执行析构函数 <?php class firecat{ public $name; function say(){ echo 'I lov ...
- sicily 1259. Sum of Consecutive Primes
Description Some positive integers can be represented by a sum of one or more consecutive prime numb ...
- mac 卸载 node并重新安装
系统升级到 Sierra 之后,npm 经常出问题,最终把 node 卸载了,安装了新版本.mac 卸载 node 比较麻烦,stackoverflow 上面找到一个方法还不错,特地记录下来,代码如下 ...
- /etc/issue 与 /etc/issue.net 文件，telnet登陆前的显示
在使用文本设备(关于文本设备的例子,见下面的说明)登录Linux系统之前,系统会显示一条被称作“issue”的消息: 若是通过本地文本设备(如本地终端,本地虚拟控制台等)登录,则该信息存放与/etc/ ...
- NOIP填坑计划
斗地主 华容道 开车旅行 疫情控制 飞扬的小鸟 Mayan游戏 天天爱跑步
- Python抓取微博评论
本人是张杰的小迷妹,所以用杰哥的微博为例,之前一直看的是网页版,然后在知乎上看了一个抓取沈梦辰的微博评论的帖子,然后得到了这样的网址 然后就用m.weibo.cn进行网站的爬取,里面的微博和每一条微博 ...
- coding.net--多人合作开发git的使用
// 从conding拉下新项目 mkdir test cd test git clone https // 安装cocoapods gem sources --remove https://ruby ...
- Java的Stack类实现List接口真的是个笑话吗
今天在网上闲逛时看到了这样一个言论,说“Java的Stack类实现List接口的设计是个笑话”. 当然作者这篇文章的重点不是这个,原本我也只是一笑置之,然而看评论里居然还有人附和,说“Ja ...