java用什么代替了指针 Java语言没有指针,怎样实现链表

大家好，今天给各位分享java用什么代替了指针的一些知识，其中也会对Java语言没有指针,怎样实现链表进行解释，文章篇幅可能偏长，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在就马上开始吧！

Java语言没有指针,怎样实现链表

Java语言中的对象引用实际上是一个指针（这里的指针均为概念上的意义，而非语言提供的数据类型），所以我们可以编写这样的类来实现链表中的结点。

程序代码：

classNode

{

Objectdata;

Nodenext;//指向下一个结点

}

将数据域定义成Object类是因为Object类是广义超类，任何类对象都可以给其赋值，增加了代码的通用性。为了使链表可以被访问还需要定义一个表头，表头必须包含指向第一个结点的指针和指向当前结点的指针。为了便于在链表尾部增加结点，还可以增加一指向链表尾部的指针，另外还可以用一个域来表示链表的大小，当调用者想得到链表的大小时，不必遍历整个链表。

链表的数据结构我们可以用类List来实现链表结构，用变量Head、Tail、Length、Pointer来实现表头。存储当前结点的指针时有一定的技巧，Pointer并非存储指向当前结点的指针，而是存储指向它的前趋结点的指针,当其值为null时表示当前结点是第一个结点，因为当删除当前结点后仍需保证剩下的结点构成链表，如果Pointer指向当前结点，则会给操作带来很大困难。如何得到当前结点呢？我们定义了一个方法cursor(),返回值是指向当前结点的指针。类List还定义了一些方法来实现对链表的基本操作，通过运用这些基本操作我们可以对链表进行各种操作。例如reset()方法使第一个结点成为当前结点。insert(Objectd)方法在当前结点前插入一个结点，并使其成为当前结点。remove()方法删除当前结点同时返回其内容，并使其后继结点成为当前结点，如果删除的是最后一个结点，则第一个结点变为当前结点。

链表类List的源代码如下：

packagecn.javatx;importjava.io.IOException;/**

*@authorljfan

*

*/

publicclassList{

privateNodeHead=null;

privateNodeTail=null;

privateNodePointer=null;

privateintLength=0;publicvoiddeleteAll(){

Head=null;

Tail=null;

Pointer=null;

Length=0;

}publicvoidreset(){

Pointer=null;

}publicbooleanisEmpty(){

return(Length==0);

}publicbooleanisEnd(){

if(Length==0)

thrownewjava.lang.NullPointerException();

elseif(Length==1)

returntrue;

else

return(cursor()==Tail);

}publicObjectnextNode(){

if(Length==1)

thrownewjava.util.NoSuchElementException();

elseif(Length==0)

thrownewjava.lang.NullPointerException();

else{

Nodetemp=cursor();

Pointer=temp;

if(temp!=Tail)

return(temp.next.data);

else

thrownewjava.util.NoSuchElementException();

}

}publicObjectcurrentNode(){

Nodetemp=cursor();

returntemp.data;

}publicvoidinsert(Objectd){

Nodee=newNode(d);

if(Length==0){

Tail=e;

Head=e;

}else{

Nodetemp=cursor();

e.next=temp;

if(Pointer==null)

Head=e;

else

Pointer.next=e;

}

Length++;

}publicintsize(){

return(Length);

}publicObjectremove(){

Objecttemp;

if(Length==0)

thrownewjava.util.NoSuchElementException();

elseif(Length==1){

temp=Head.data;

deleteAll();

}else{

Nodecur=cursor();

temp=cur.data;

if(cur==Head)

Head=cur.next;

elseif(cur==Tail){

Pointer.next=null;

Tail=Pointer;

reset();

}else

Pointer.next=cur.next;

Length--;

}

returntemp;

}privateNodecursor(){

if(Head==null)

thrownewjava.lang.NullPointerException();

elseif(Pointer==null)

returnHead;

else

returnPointer.next;

}publicstaticvoidmain(String[]args){

Lista=newList();

for(inti=1;i<=10;i++)

a.insert(newInteger(i));

System.out.println(a.currentNode());

while(!a.isEnd())

System.out.println(a.nextNode());

a.reset();

while(!a.isEnd()){

a.remove();

}

a.remove();

a.reset();

if(a.isEmpty())

System.out.println("ThereisnoNodeinListn");

System.out.println("Youcanpressreturntoquitn");

try{

System.in.read();

}catch(IOExceptione){

}

}

}classNode{

Objectdata;

Nodenext;Node(Objectd){

data=d;

next=null;

}

}

当然，双向链表基本操作的实现略有不同。链表和双向链表的实现方法，也可以用在堆栈和队列的现实中。

java中到底有没有指针

学过c/c++，然后学Java的人往往心中有此纠结，java中到底有没有指针？

如果一定要在是或否里选择一个，OK，java中没有指针。

那么，java中的引用（reference）和c/c++中的指针（如无特别说明，后文指针均指c/c++中的指针）究竟有着什么样纠葛不清的关系呢？

在开始之前先说一下c/c++的引用，它跟java的引用完全不是一个东西，c/c++的引用是同一块内存的不同名字。而java的引用是指向一个对象，引用本身也占用了内存。

首先，列举一下能对指针进行的一些常见操作：

1、指向一个对象,如 Person*p= new Person….；int*iv= new int….

2、对指针所指的对象进行操作：P->getAge();(*p).getAge();

3、获取存储在指针中的地址值。

4、将指针指向另外一个对象:Person*p1= new Person…; p= p1;但，不可以*p= p1这样来赋值。

5、删除new的空间，delete p1;

6、其它诸多操作

这么多已经足够了，接下来看看java引用能做什么操作。

a、指向一个对象，如Person p= new Person…

b、调用对象的方法，p.getAge();

c、指向另外一个对象，Person p1= new Person…; p= p1;

OK，就这么多了。

对于a和1，他们的功能是类似的，但java引用无法指向一个基本变量。。

对于b，java引用和指针就不同了，在这点上，Java reference更像是解引用（dereference）了的指针；或者说java中的.操作符某种程度上等价于指针的->操作符，如果是这样种解释的话，我们无法再对java的reference解引用了。

对c和4，是类同的。

除此，我们无法获取java引用存的地址，我们不能delete，还有很多……

综上，窃以为java的引用可以看成是一个功能受限的指针（或者说被阉割的指针）。另一方面，功能如此受限，它还能叫指针吗？了解了指针和java引用的区别与联系，还需要纠结“java中有没有指针”这个问题吗！

java中指针操作是什么意思

众所周知，在java里面是没有指针的。那为何此处还要说java里面的“指针”呢？我们知

道在C/C++中，指针是指向内存中的地址，该地址就是存储变量的值。该地址所存储的变量值是“公有”的，此处的“公有”是对于拥有该地址的变量而言。它

们都可以访问该地址的内容，并且可对其就行修改，一经修改则所有指向该地址的变量值也将改变。那么在Java里面何来的指针？在java里面没有指针的定

义。但是java里面的“指针”无处不在。下面将进行介绍。我们知道JAVA里面用的最多的就是对象，我们经常将一个对象传递给不同的变量，例如：

Student s1= new Student();

Student s2= s1;

此时s1和s2是指向同一个对象的，也就是s1和s2引用同一个对象，我们知道java里面创建一个对象是存放在堆的，当我们new一个对象的时候其实是

在堆中开辟了一个存储该对象的空间，返回是的存储该对象在堆中的地址，所以在java中我们所谓的对象引用就是指针，只是没有像C/C++中给出了一个明

确的定义。java是为了避免指针带来的使用上的麻烦，所以就使用对象的引用来代替了指针。上面的例子中，当我们在s1中进行修改Student中的属性

的时候，那么当s2取Student中属性的值的时候便是取得了s1修改后的值，这是因为s1和s2是指向堆中的同一块内容，所以只要其中一个变量修改了

堆中的值，则其他的变量将取得堆中最后更新的值。所以我们可以知道，s2=s1并不是又在堆中创建了一块内存，而只是把一个对象的地址赋给了s2，此时还

是只是创建了一个对像，而不是两个。在实际开发中会经常碰到这些，假设创建一个Map<String,Object>类型的对象，它的

value是一个对象，而key是一个字符串，定义如下：

class Student{

private String name;

private int age;

public void setAge(int age)

{

this.age= age;

}

public Student(String name)

{

this.name= name;

}

}

Map<String,Student> studentMap= new HashMap<String,Student>();

Student s1= new Student("张三");

Student s2= new Student("李四");

studentMap.put(s1.name,s1);

studentMap.put(s2.name,s2);

此处是一个学生姓名对应了一个

学生，所以此处的Map的key是学生姓名，value是一个学生对象。那么就是将一个Student对象的引用赋给了Map中key所对应的

value，所以当程序在别处改变了s1/s2的值后，不必将s1和s2的信息更新到studentMap中，studentMap就会获得key所对应

的value最新的值，例如：在程序的某处我们将s1的age修改成了“23”，我们不必将s1的最新信息更新到studentMap

中，studentMap就会获得s1的最新值。这是因为已经将s1对象的引用赋给了studentMap中张三所对应的value，也就是将对象在堆中

的地址赋给了value。所以只要s1一更新，studentMap就可以获得最新的值。

有时候这种情况会影响我们程序的执行和我们想想的会有偏差，当我们需要保存一个对象在某时刻的状态时，按照一般的理解是将此时的对象赋给一个变量来进行

存储，但是在java里面这样是行不通的！因为这样直接将该对象赋给另一个变量只是将该对象的引用赋给了此变量，该变量的值并不能保持在此刻该对象的值，

会随着程序的执行，该对象的改变而变化。所以达不到我们的目的。下面就举个例子来说明解决该现象：

class Student{

private String name;

private int age;

public void setAge(int age)

{

this.age= age;

}

public Student(String name)

{

this.name= name;

}

public Student(Student student)

{

this.name= student.name;

this.age= student.age;

}

}

上面还是student类，基

本和上面一样，只是多添加了一个构造函数——Student(Student

student)，为什么要多加这样一个函数呢？这就是为了满足我们上面的需求（保存对象某个时刻下的状态），我们知道直接将一个对象赋给一个变量会存在

对象的引用，不能保存对象某时刻的状态。同时也知道要想保存一个对象就要在堆中开辟一个空间，用于存放我们的对象。其实上面的需求可以看做当我们要保存某

时刻下对象的状态，其实就是该对象的状态不会随以后对象的变化而变化，所以何不将当前某时刻下对象的状态属性全部都复制到一个新的对象中去！这样保存下来

的属性就不会受以后对象的变化而变化了。就上面的例子，举例说明：

Student s1= new Student("王麻子");

s1.age=23;

........

//此时要保存s1此刻的状态

Student s2= new Student(s1);

此时s1和s2就不是指向堆中的一个地址了，因为s2不是直接将s1赋给它的，而是通过new出来的！上面说了new可以在堆中开辟一个存储当前new的

对象的空间。这种操作可以实现将s1中的状态全都转移到s2中，所以在值的方面看s2和s1此时是一样的，但是在堆中确实不一样的，s1!=s2，因为

s1和s2的hashcode不一样！但是s1.name.equal(s2.name)==ture,s1.age=s2.age。这不就实现了保存某

个对象某个时刻下的状态了吗？而切不会在受程序执行的影响！

到此已全部介绍完有关java“指针”，其实java“指针”就是对象的引用，而对象就是存放在堆中的。我们知道java中的内存分为堆内存（heap）

和栈内存（stack）。堆就是用来存放对象的，而栈则是存放一些数据基本类型的值，如int,float,double,char.......。

关于java用什么代替了指针到此分享完毕，希望能帮助到您。