❶ java中LinkedList问题
那个没有错误，只是返猜正一个警告，可以漏悔不用理睬的
也可以
@SuppressWarnings("unchecked") //添加兆早这个就可以了
public void push(Object o) {
l.addFirst(o);
}
或者
private LinkedList<Object> l = new LinkedList<Object>(); 都可以
❷ java中LinkedList的问题
//单链表类
package dataStructure.linearList;
import dataStructure.linearList.Node; //导入单链表结点类
import java.util.Iterator; //导入迭代器接口
public class SinglyLinkedList<E> extends AbstractList<E> implements LList<E> //单链表类，实橘早厅现线性表接口
{
protected Node<E> head; //头圆隐指针，指向单链表第1个结点
public SinglyLinkedList() //构造空单链表
{
this.head = null;
}
public SinglyLinkedList(Node<E> head) //构造指定头指针的单链表
{
this.head = head;
}
public boolean isEmpty() //判断单链表是否为空睁碧，O(1)
{
return this.head==null;
}
public int length() //返回单链表长度
{ //单链表遍历算法，O(n)
int i=0;
Node<E> p=this.head;
while (p!=null)
{
i++;
p = p.next;
}
return i;
}
public E get(int index) //返回序号为index的对象，index初值为0
{ //若单链表空或序号错误返回null，O(n)
if (this.head!=null && index>=0)
{
int j=0;
Node<E> p=this.head;
while (p!=null && j<index)
{
j++;
p = p.next;
}
if (p!=null)
return (E)p.data;
}
return null;
}
public E set(int index, E element) //设置序号为index的对象为element，O(n)
{ //若操作成功返回原对象，否则返回null
if (this.head!=null && index>=0 && element!=null)
{
int j=0;
Node<E> p=this.head;
while (p!=null && j<index)
{
j++;
p = p.next;
}
if (p!=null)
{
E old = (E)p.data;
p.data = element;
return old; //若操作成功返回原对象
}
}
return null; //操作不成功
}
public boolean add(int index, E element) //插入element对象，插入后对象序号为index
{ //若操作成功返回true，O(n)
if (element==null)
return false; //不能添加空对象（null）
if (this.head==null || index<=0) //头插入
this.head = new Node<E>(element, this.head);
else //单链表不空且index>=1
{
int j=0;
Node<E> p=this.head;
while (p.next!=null && j<index-1) //寻找插入位置
{
j++;
p = p.next;
}
p.next = new Node<E>(element, p.next);//中间/尾插入
}
return true;
}
public boolean add(E element) //在单链表最后添加对象，重载，O(n)
{
return add(Integer.MAX_VALUE, element);
}
public E remove(int index) //移去序号为index的对象，O(n)
{ //若操作成功返回被移去对象，否则返回null
E old = null;
if (this.head!=null && index>=0)
if (index==0) //头删除
{
old = (E)this.head.data;
this.head = this.head.next;
}
else //中间/尾删除
{
int j=0;
Node<E> p=this.head;
while (p.next!=null && j<index-1) //定位到待删除结点的前驱结点
{
j++;
p = p.next;
}
if (p.next!=null)
{
old = (E)p.next.data; //操作成功，返回原对象
p.next = p.next.next; //删除p的后继结点
}
}
return old;
}
public void clear() //清空单链表，O(1)
{
this.head = null;
}
public String toString() //返回显示单链表所有元素值对应的字符串
{ //单链表遍历算法，O(n)
String str="(";
Node<E> p = this.head;
while (p!=null)
{
str += p.data.toString();
p = p.next;
if (p!=null)
str += ", ";
}
return str+")";
}
//以上实现LList接口，第2章
//以下2.4 迭代器内容
public Iterator<E> iterator() //返回一个迭代器对象
{
return new Itr();
}
private class Itr implements Iterator<E> //私有内部类，实现迭代器接口
{
private Node<E> cursor = head;
public boolean hasNext() //若有后继元素，返回true
{
return cursor!=null && cursor.next!=null;
}
public E next() //返回后继元素
{
if (cursor != null && cursor.next!=null)
{
E element = cursor.next.data;
cursor = cursor.next;
return element;
}
return null;
}
public void remove() //不支持该操作
{
throw new UnsupportedOperationException();
}
}//内部类Itr结束
//以下第8章 8.2.1 顺序查找，散列表中用
public Node<E> search(E element, Node<E> start) //从单链表结点start开始顺序查找指定对象
{ //若查找成功返回结点，否则返回null
if (this.head==null || element==null)
return null;
Node<E> p=start;
while (p!=null && !element.equals(p.data))
{
System.out.print(p.data+"? ");
p = p.next;
}
return p;
}
public Node<E> search(E element) //顺序查找指定对象
{
return search(element, head);
}
/*
public boolean contain(E element) //以查找结果判断单链表是否包含指定对象
{ //若包含返回true，否则返回false
return this.search(element)!=null;
}
*/
public boolean remove(E element) //移去首次出现的指定对象，O(n)
{ //若操作成功返回true
if (this.head==null || element==null)
return false;
if (element.equals(this.head.data))
{
this.head = this.head.next; //头删除
return true;
}
Node<E> front=this.head, p=front.next; //中间/尾删除
while (p!=null && !element.equals(p.data))
{
front = p;
p=p.next;
}
if (p!=null)
{
front.next = p.next;
return true;
}
return false;
}
//以下是第2章习题
public SinglyLinkedList(E[] element) //由指定数组中的多个对象构造单链表
{
this.head = null;
if (element!=null && element.length>0)
{
this.head = new Node(element[0]);
Node<E> rear=this.head;
int i=1;
while (i<element.length)
{
rear.next = new Node(element[i++]);
rear = rear.next;
}
}
}
public void concat(SinglyLinkedList list) //将指定单链表list链接在当前单链表之后
{
if (this.head==null)
this.head = list.head;
else
{
Node<E> p=this.head;
while (p.next!=null)
p = p.next;
p.next = list.head;
}
}
public SinglyLinkedList(SinglyLinkedList<E> list) //以单链表list构造新的单链表
{ //复制单链表
this.head = null;
if (list!=null && list.head!=null)
{
this.head = new Node(list.head.data);
Node<E> p = list.head.next;
Node<E> rear = this.head;
while (p!=null)
{
rear.next = new Node<E>(p.data);
rear = rear.next;
p = p.next;
}
}
}
//递归方法
// public SinglyLinkedList(SinglyLinkedList<E> list) //以单链表list构造新的单链表
public void (SinglyLinkedList<E> list) //复制单链表
{
this.head = (list.head);
}
private Node<E> (Node<E> p) //复制单链表，递归方法
{
Node<E> q=null;
if (p!=null)
{
q = new Node(p.data);
q.next = (p.next);
}
return q;
}
/*//递归方法
public String toString()
{
return "("+ this.toString(this.head) +")";
}
public String toString(Node<E> p) //递归方法
{
if (p!=null)
return p.data.toString() + ", " + this.toString(p.next); //递归调用
return "";
}
public SinglyLinkedList(E[] element) //由指定数组中的多个对象构造单链表
{
this.head = null;
if (element!=null)
this.head = create(element,0);
}
private Node<E> create(E[] element, int i) //由指定数组构造单链表
{ //递归方法
Node<E> p=null;
if (i<element.length)
{
p = new Node(element[i]);
p.next = create(element, i+1);
}
return p;
}
*/
public boolean equals(Object obj) //比较两条单链表是否相等
{
if (obj == this)
return true;
if (obj instanceof SinglyLinkedList)
{
SinglyLinkedList list = (SinglyLinkedList)obj;
return equals(this.head, list.head);
}
return false;
}
private boolean equals(Node<E> p, Node<E> q) //比较两条单链表是否相等，递归方法
{
if (p==null && q==null)
return true;
if (p!=null && q!=null)
return p.data.equals(q.data) && equals(p.next, q.next);
return false;
}
//以下是第8章习题
public boolean replace(Object obj, E element)//将元素值为obj的结点值替换为element，O(n)
{ //若替换成功返回true，否则返回false
if (obj==null || element==null)
return false;
Node<E> p=this.head;
while (p!=null)
{
if (obj.equals(p.data))
{
p.data = element;
return true;
}
p = p.next;
}
return false;
}
public boolean replaceAll(Object obj, E element) //将所有元素值为obj的结点值替换为element，O(n)
{ //若替换成功返回true，否则返回false
boolean done=false;
if (obj!=null && element!=null)
{
Node<E> p=this.head;
while (p!=null)
{
if (obj.equals(p.data))
{
p.data = element;
done = true;
}
p = p.next;
}
}
return done;
}
public boolean removeAll(Object obj) //将所有元素值为obj的结点删除
{
if (this.head==null || obj==null)
return false;
boolean done=false;
while (this.head!=null && obj.equals(this.head.data))
{
this.head = this.head.next; //头删除
done = true;
}
Node<E> front=this.head, p=front.next;
while(p!=null)
{
if (obj.equals(p.data))
{
front.next = p.next; //删除p结点
p = front.next;
done = true;
}
else
{
front = p;
p = p.next;
}
}
return done;
}
public static void main(String[] args)
{
String[] letters={"A","B","C","D","E","F"};
SinglyLinkedList<String> list1 = new SinglyLinkedList<String>(letters);
SinglyLinkedList<String> list2 = new SinglyLinkedList<String>(list1);
list2.(list1);
System.out.println(list2.toString());
System.out.println("equals()， "+list2.equals(list1));
}
}
/*
程序运行结果如下：
(A, B, C, D, E, F)
*/
/* 第2章 //可行，但效率低，时间复杂度是O(n*n)。
public String toString()
{
String str="{";
if (this.length()!=0)
{
for(int i=0; i<this.length()-1; i++)
str += this.get(i).toString()+", ";
str += this.get(this.length()-1).toString();
}
return str+"}";
}
*/
❸ ArrayList和LinkedList中的transient关键字和序列化
在看ArrayList和LinkedList的 源码 的时候，发现ArrayList和LinkedList的一些成员变量变量被transient修饰了，有点不解，就查了一些资料。分享给大家。
序列化是java提供的一种将内存中的对象信息转化为二进制数组的方法，可以将数组保存和传输，然后使用原来的类模板恢复对象的信息。源颂贺
转化后的二进制数组中包含以下信息：序列化版本，完整类名，serialVersionUID，各个属性的类型、名字和值、父类信息。
实现Serializable接口，使用ObjectOutputStream.writeObject(Object Object)写对象信息，使用ObjectInputStream.readObject()读对象信息。
ObjectOutputStream.writeObject(ObjectA objectA)首先判断ObjectA有没有重写writeObject方法，如果有，反射调用ObjectA的writeObject方法完成序列化；否则，调用默认的序列化方法序列化。反序列化也一样
被transient修饰的成员变量不会被序列化。
哪些情况下可以不用序列化呢？我认为有以下两种情况。
1.节省空间
比如，一个长方形类有成员变量：长、宽、面积。那么面积就不用序列化，因为面积可以根据其他两个计算出来，这样节省存储空间和传输空间。
2.持有对象的引用
比如，我们创建链表的结点如下。结点中持有前驱结点和后继结点的引用，引用就是对象在内存中的地址值。对于这样的结点形成的链表，我们序列化这个链表后，结点的前序和后继引用都失效了，因为内存地址变了。这种情况下我们需要重新连接链表。
首先说以下结论：
1.ArrayList中将elementData修饰成transient是为了节省空间
2.LinkedList中将first和last修饰成transient是为了节省空间和重新连接链表。
查看 源码 我们知道ArrayList中使用数组transient Object[] elementData保存数据，当数组空间不够时，数组长度扩容为原来的1.5倍。那么数组中可能有没有使用的空间，比如elementData的长度时15，但是里面只装了11个元素，那么后面的4个元素都是空值。序列化的时候可以不把这4个元素序列化。
ArrayList中定义了writeObject和readObject方法，实现了自定义序列化。前面我们说了序列化的时候ObjectStream会判断类中有没有自定义序列化方法？如果有，使用自定义序列化方法：否则使用默认的序列化方法。
ArrayList自定义序列化方法如下
查看 源码 我们知道LinkedList中使用双向链表樱培保存数据，结点中保存前驱和后继的引用。但是序列化之后前序结点和后继结点的地址都变了，我们应该连接新的结点。
下面看以下LinkedList是怎么自定义序列化的
我们看到了，LinkedList序列化的时候将链表按顺序拆分开来，仅序列化结雹派点中保存的数据，反序列化的时候重新连接链表，保证了链表的有效性。
❹ java中源文件LinkedList.java
在 AbstractList 中定义的，初始值是 0。笑桥岁
api 中对此有比较具体的说明，摘给你：
---------------------------------------------------------------
protected transient int modCount
已从结构上修改 此列表的次数。从结构上修改是指更改列表的大小，或者打乱列表，从而使正在进行的迭代产生错误的结果。
此字段由 iterator 和 listIterator 方法返回的迭代器和列表迭代器实现使用。如果意外更改了此字段中的值，则迭代器（或列表迭代器）将抛出 来响应 next、remove、previous、set 或 add 操作。在迭代期间面临并发修改时，它提供了快速失败 行为，而不是非确定性行为。
子类是否使用此字段是可选的。如果子类希望提供快速失败迭代器（和列表迭代器），则它只需在其 add(int, E) 和 remove(int) 方法（以及它所重写的、导致列表消慧结构上修改的任何其他方法）中增加此字段。对 add(int, E) 或 remove(int) 的单个调用向此字段添加的数量不得超过 1，否则迭代器（和列表迭代器）将抛出虚假的 s。如果某个实现不希望提供快速失败迭碰睁代器，则可以忽略此字段。
❺ Java LinkedList问题
这跟腔则并发有毛关系啊，你们在哪能看出这个程序有并发？
只是在迭代的时候把尾元素删除核纤了，所以it.next()遍历的元素伍氏棚不一致报的错
JDK源码
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ();
}
与期待值不同报 异常
❻ Java中的linkedlist有两个方法，element()和getFirst(),有什么不一样
这种最好的就是看jdk源码和源码上的注释，以及编写测试代码实际调用测试一下。
看jdk源码，LinkedList<E>源码
先看getFirst()
/**
*Returns改扮thefirstelementinthislist.
*
*@returnthefirst斗歼唤elementinthislist
*@
*/
publicEgetFirst(){
finalNode<E>f=first;
if(f==null)
();
returnf.item;
}
看注释Returns the first element in this list，返回列表的第一个元素，没毛病。
然空凯后来看element()
/**
*Retrieves,butdoesnotremove,thehead(firstelement)ofthislist.
*
*@returntheheadofthislist
*@
*@since1.5
*/
publicEelement(){
returngetFirst();
}
结果…… LinkedList 里面 element()就是直接调用的getFirst()方法
❼ java中的LinkedList的问题在线等，急
import java.util.LinkedList;
/*
*利用LinkedList来实现堆或慧码栈
*LinkedList容器具有有续性,以及插入删除方便的特衫哪征
*
*/
public class Stack<T>{
/碧慎/建立一个链表保存数据
private LinkedList<T> stack;
public Stack(){
stack = new LinkedList<T>();
}
//入栈操作
public void push(T obj){
stack.addFirst(obj);
}
//获取栈顶元素
public T top(){
//判断栈是否为空
if(!isEmpty()){
return stack.getFirst();
}else{
return null;
}
}
//出栈操作
public T pop(){
//判断栈是否为空
if(!isEmpty()){
return stack.removeFirst();
}else{
return null;
}
}
//判断栈是否为空
public boolean isEmpty(){
return stack.isEmpty();
}
//测试堆栈
public static void main(String[] args){
String[] list = "my name is beyondlife".split(" ");
Stack<String> stack = new Stack<String>();
for(String obj : list){
stack.push(obj);
}
while(stack.peek() != null){
System.out.print(stack.pop() + " ");
}
}
}
给你改好了，回答个问题真是不容易，你自己改也行啊，这么简单
❽ 【java】帮看一个LinkedList的小代码。万分感谢！！
你好，我帮你找到了世斗孝出现的原因。
下面我们分析下你的构造方法：
DuiLie()
{
link = new LinkedList();
li = link.listIterator(); //注意这里。
}
当你对象在创建的时候，li就已经被初始化好了。
后面的add时，link会改变，但是li已经不会在变化了。所以出现了上面提到的异常。
修改办法就是修改add方法：
public void add(Object obj) {
link.offerFirst(obj);
li = link.listIterator();
}
但是你的逻辑（设计）还是销闷有问题的，我意思你自搜稿己在想想，那样才是自己的东西，我就不多说了。
❾ Java使用LinkedList来模拟一个队列(先进先出的特性)
importjava.util.LinkedList;
publicclassDemo01{
privateLinkedList<Object>linkedList;
publicDemo01(){
linkedList=newLinkedList<Object>();
}
publicvoidput(Objectobject){
linkedList.add(object);
}
publicObjectget(){
Objectobject=null;
if(linkedList.size()!=0){
object=linkedList.get(0);
linkedList.remove(0);
}
returnobject;
}
publicbooleanisEmpty(){
if(linkedList.size()!=0){
returntrue;
}else{
returnfalse;
}
}
publicstaticvoidmain(String[]args){
Demo01demo01=newDemo01();
demo01.put("1");
demo01.put("2");
System.out.println(demo01.get());
System.out.println(demo01.get());
System.out.println(demo01.isEmpty());
}
}
结果：
1
2
false
❿ java语言中用LinkList实现堆栈
栈和队列是两种特殊的线性表，它们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制，故又称它们为运算受限的线性表。
LinkedList数据结构是一种双向的链式结构，每一个对象除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素，和数组的顺序存储结构（如：ArrayList）相比，插入和删除比较方便，但速度会慢一些。
栈的定义
栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。
(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。
(2)当表中没有元素时称为空栈。
(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。
栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。
实现代码：
package com.weisou.dataStruct;
import java.util.LinkedList;
@SuppressWarnings("unchecked")
public class MyStack {
LinkedList linkList = new LinkedList<Object>();
public void push(Object object) {
linkList.addFirst(object);
}
public boolean isEmpty() {
return linkList.isEmpty();
}
public void clear() {
linkList.clear();
}
// 移除并返回此列表的第一个元素
public Object pop() {
if (!linkList.isEmpty())
return linkList.removeFirst();
return "栈内无元素";
}
public int getSize() {
return linkList.size();
}
public static void main(String[] args) {
MyStack myStack = new MyStack();
myStack.push(2);
myStack.push(3);
myStack.push(4);
System.out.println(myStack.pop());
System.out.println(myStack.pop());
}
}
队列定义
队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表
（1）允许删除的一端称为队头（Front）。
（2）允许插入的一端称为队尾（Rear）。
（3）当队列中没有元素时称为空队列。
（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。
实现代码：
package com.weisou.dataStruct;
import java.util.LinkedList;
/**
*
* @author gf
* @date 2009-11-13
*/
public class MyQueue {
LinkedList linkedList = new LinkedList();
//队尾插
public void put(Object o){
linkedList.addLast(o);
//队头取 取完并删除
public Object get(){
if(!linkedList.isEmpty())
return linkedList.removeFirst();
else
return "";
}
public boolean isEmpty(){
return linkedList.isEmpty();
}
public int size(){
return linkedList.size();
}
public void clear(){
linkedList.clear();
}
/**
* @param args
*/
public static void main(String[] args) {
MyQueue myQueue= new MyQueue();
myQueue.put(1);
myQueue.put(2);
myQueue.put(3);
System.out.println(myQueue.get());
}
}