Java系列（九）__链表
Java系列（九）__链表
1、链表
学习到现在有两个概念没有讲解透彻：
· this表示当前对象，只是在对象比较中简单的应用了一次；
· 内部类做什么用？
在之前所编写的第二个代码模型利用的是对象数组完成的，但是成是对象数组，败也是对象数组，因为对象数组有着严格的顺序索引同时不可修改大小。所以必须利用自己的代码进行问题的解决。
链表 = 动态对象数组，是利用引用关系的组合实现的，所以来讲本处都是引用关系的操作。
1.1、基本操作形式
在现实之中有可能出现这样一种情况：从的领导是顾，顾的领导是谢、谢的领导是刁，刁的领导是金。现在如果由我们个人来表示这样的关系，那么类该如何设计？
范例：问题的引出
| class Emp { private String name ; private Emp mgr ; // 领导 public Emp(String name) { this.name = name ; } public void setMgr(Emp mgr) { this.mgr = mgr ; } public Emp getMgr() { return this.mgr ; } public String getName() { return this.name ; } } public class LinkDemo { public static void main(String args[]) { Emp ea = new Emp("从") ; Emp eb = new Emp("顾") ; Emp ec = new Emp("谢") ; Emp ed = new Emp("刁") ; Emp ee = new Emp("金") ; ea.setMgr(eb) ; eb.setMgr(ec) ; ec.setMgr(ed) ; ed.setMgr(ee) ; } } |
现在通过如上的设计关系，可以发现，所有的对象就可以像一个个节点一样，进行连接。
范例：定义节点类
| class Node { // 只是作为一个数据的载体 private String data ; // 假设现在存放的是String型 private Node next ; // 下一个节点 public Node(String data) { // 有数据才应该有节点 this.data = data ; } public String getData() { return this.data ; } public void setNext(Node next) { this.next = next ; } public Node getNext() { return this.next ; } } |
范例：设置节点的关联
| public class LinkDemo { public static void main(String args[]) { // 第一层：设置节点关系 Node root = new Node("数据A") ; Node n1 = new Node("数据B") ; Node n2 = new Node("数据C") ; root.setNext(n1) ; n1.setNext(n2) ; // 第二层：取出节点关系 Node currentNode = root ; // 当前操作节点 while(currentNode != null) { // 有节点 System.out.println(currentNode.getData()) ; currentNode = currentNode.getNext() ; // 改变当前节点 } } } |
但是很明显以上的代码通过循环的方式并不好，最好的方式是使用递归进行输出。
范例：通过递归实现输出
| public class LinkDemo { public static void main(String args[]) { // 第一层：设置节点关系 Node root = new Node("数据A") ; Node n1 = new Node("数据B") ; Node n2 = new Node("数据C") ; root.setNext(n1) ; n1.setNext(n2) ; print(root) ; // 从root开始输出 } public static void print(Node currentNode) { if (currentNode != null) { System.out.println(currentNode.getData()) ; print(currentNode.getNext()) ; } } } |
以上通过设置节点保存，就可以发现可以保存无数的信息，没有长度限制。
1.2、链表的基本概念
通过以上的分析可以发现现在的问题：用户需要自己准备好数据，需要自己定义节点，需要自己设置节点关系，取得的时候要分析节点组成后取出数据，这些实在是太麻烦了，用户关心的只是数据往那里保存，从那里得到。
所以应该有一个类专门进行节点的操作，即：用户不应该去关心Node类之间的操作。于是现在要准备出一个Link类，这个类负责操作Node。
在整个的Link类之中最需要关心的就是第一个节点（根节点）只有存在了根节点，才可以进行后期的所有操作。
范例：实现代码
| class Node { // 只是作为一个数据的载体 private String data ; // 假设现在存放的是String型 private Node next ; // 下一个节点 public Node(String data) { // 有数据才应该有节点 this.data = data ; } public String getData() { return this.data ; } public void setNext(Node next) { this.next = next ; } public Node getNext() { return this.next ; } // 第一次（Link）：this = Link.root // 第二次（Node）：this = Link.root.next // 第三次（Node）：this = Link.root.next.next public void addNode(Node newNode) { if (this.next == null) { // 当前的下一个节点为null this.next = newNode; // 保存新节点 } else { this.next.addNode(newNode) ; } } // 第一次（Link）：this = Link.root // 第二次（Node）：this = Link.root.next public void printNode() { System.out.println(this.data) ; if (this.next != null) { this.next.printNode() ; } } } class Link { // 专门操作节点 private Node root ; // 根节点 public void add(String data) { // 保存数据 // 将数据封装在节点之中，因为只有封装之后才可以设置节点关系 Node newNode = new Node(data) ; if (this.root == null) { // 现在没有根节点 this.root = newNode ; // 第一个作为根节点 } else { this.root.addNode(newNode) ; } } public void print() { if (this.root != null) { // 有数据 this.root.printNode() ; // 交给Node类处理 } } } public class LinkDemo { public static void main(String args[]) { Link all = new Link() ; all.add("货物A") ; all.add("货物B") ; all.add("货物C") ; all.print() ; } } |
以上就是一个最最最最最简单的链表操作，也包含了所有链表的基本操作形式。
1.3、开发可用链表
之前的代码只能够说是满足了链表的基本形式要求，但是代码不可用。最核心的问题在于，所有的数据都是直接进行输出的，这在实际的工作上根本就无法去使用。但是通过之前的程序也可以发现一点问题：
· Node类是整个链表节点配置关系的核心部分，但是用户不需要知道Node类存在，但是在之前的程序，发现Node类用户可以直接去使用，不合法；
· Link类作为节点排列的操作类，一定要建立好根节点。
范例：首先修改程序的基本组成
| class Link { // 用户最需要关注的是这个类 // Node类不希望被其它类使用，但是Link类要使用 private class Node { // 存储数据和配置节点关系 private String data ; // 假设现在保存的是String private Node next ; // 下一个节点 public Node(String data) { // 节点要有数据 this.data = data ; } } // ********************************** private Node root ; // 根节点 } |
而在本结构之中最重要的几个操作：增加、删除、查找、输出全部。
1.3.1、增加数据：public void add(数据类型 对象)
1、 首先需要在Link类里面增加一个add()方法；
2、 将传入的数据封装为一个Node类对象，封装的好处是可以进行节点的排列，此方法中的数据类型一定要与Node类之中data属性的类型相同；
| class Link { // 用户最需要关注的是这个类 // Node类不希望被其它类使用，但是Link类要使用 private class Node { // 存储数据和配置节点关系 private String data ; // 假设现在保存的是String private Node next ; // 下一个节点 public Node(String data) { // 节点要有数据 this.data = data ; } public void addNode(Node newNode) { if (this.next == null) { // 当前节点的下一个为null this.next = newNode ; } else { this.next.addNode(newNode) ; } } } // ********************************** private Node root ; // 根节点 public void add(String data){ if (data == null) { return ; // 保存的数据不为null } Node newNode = new Node(data) ; // 将数据封装为节点 if (this.root == null) { // 没有根节点 this.root = newNode ; // 新节点作为根节点 } else { // 交给Node类进行处理 this.root.addNode(newNode) ; } } } |
1.3.2、取得保存的对象个数：public int size()
每当一个新数据保存成功之后，应该进行一个数量的修改。
1、 由于需要针对于所有的节点操作，那么首先应该在Link类里面增加一个count的属性；
| private int count ; // 统计个数 |
2、 在add()方法执行完毕之后表示增加成功，所以保存的个数要增加
| this.count ++ ; // 增加个数 |
3、 在Link类里面增加一个size()方法，此方法就返回count这个属性的内容；
| public int size() { return this.count ; } |
1.3.3、判断是否是空链表：public boolean isEmpty()
如果说现在链表之中没有保存任何数据（root是null或者count为0），那么就应该返回true，否则返回false。
1、 在Link类之中增加isEmpty()方法
| public boolean isEmpty() { return this.count == 0 ; } |
如果个数为0返回true，否则返回false。
1.3.4、清空链表：public void clean()
整个链表就是靠着Link类中的root属性的，如果root的内容是null，那么链表一定都不会保存。
| public void clean() { this.root = null ; // 清空 this.count = 0 ; // 归零 } |
1.3.5、取得指定索引位置的数据：public 数据类型 get(int index)
索引号是动态生成的，那么这些节点的索引生成代码应该由Link类负责。
1、 首先在Link类之中增加一个用于标记索引的属性：foot
| private int foot ; // 用于标记索引顺序 |
2、 在Link类之中增加一个get()方法，查询数据。
| public String get(int index) { if (index > this.count) { return null ; } this.foot = 0 ; // 让脚标从0开始 return this.root.getNode(index) ; } |
3、 在Node类里面如果要进行查询，肯定要修改foot属性的内容，而幸运的是，在内部类之中可以方便的访问外部类的私有数据。
| public String getNode(int index) { if(index == Link.this.foot ++) { // 符合查找索引 return this.data ; // 返回当前节点数据 } else { return this.next.getNode(index) ; } } |
1.3.6、判断指定数据是否存在：public boolean contains(数据类型 对象)
1、 首先需要在Link类里面增加一个contains()方法，这个方法里面要先判断查询的数据是否为null。
| public boolean contains(String data) { if (data == null) { return false ; // 没有查询数据 } return this.root.containsNode(data) ; } |
2、 将查询过程交给Node类进行处理，就是将每一个节点进行比较，如果查询到了返回true，否则返回false。
| public boolean containsNode(String data) { if (data.equals(this.data)) { // 查询数据与当前节点吻合 return true ; } else { if (this.next != null) { return this.next.containsNode(data) ; } else { return false ; } } } |
1.3.7、删除数据：public void remove(数据类型 对象)
如果要想进行数据的删除操作，必须考虑两种情况：
情况一：要删除的数据是根节点（应该由Link类完成，而且在Link类里面一定已经判断完了根节点）
情况二：要删除的节点不是根节点（Node类进行，至少从第二个节点开始）
1、 首先在Link类之中增加一个remove()方法，而删除数据之前应该执行一个查询，查询要删除的数据是否存在，如果不存在就没必要删除了。如果查询到数据存在，则需要在Link类里面判断要删除的数据是否是根节点数据。
| public void remove(String data) { if(this.contains(data)) { // 查找到数据了 if (this.root.data.equals(data)) { this.root = this.root.next ; // 改变根节点 } else { // 要删除的不是根节点 this.root.next.removeNode(this.root,data) ; } this.count -- ; } } |
2、 在Node类之中进行删除操作（现在是从第二个节点开始的判断）
| public void removeNode(Node previous,String data) { if(this.data.equals(data)) { // 当前节点满足删除数据 previous.next = this.next ; // 空出当前节点 } else { // 向下继续判断 this.next.removeNode(this,data) ; } } |
1.3.8、返回全部数据：public 数据类型 [] toArray()
1、 此对象数组所有节点都应该可以看见，那么只能够定义在Link类之中。
| private String [] retData ; // 保存的对象数组 |
2、 在Link类之中增加一个toArray()方法，此方法一定是要返回retData这个属性内容，但是retData的内容应该交给Node类来处理，而开辟的大小应该是由count决定的；
| public String [] toArray() { if(this.count == 0) { return null ; // 没数据 } this.foot = 0 ; // 通过foot设置数组索引 this.retData = new String [this.count] ; // 开辟数组 this.root.toArrayNode() ; // 交给Node类处理 return this.retData ; } |
3、 在Node类之中增加一个toArrayNode()方法
| public void toArrayNode() { Link.this.retData[Link.this.foot ++] = this.data ; if (this.next != null) { this.next.toArrayNode() ; } } |
所有的链表程序不要求你会写（会写最好了），但是这些方法的作用一定要知道。
1.4、保存其它对象
以上的代码为了讲解方便，是采用了String数据类型操作的，但是在实际之中有可能需要操作的是用户定义的对象，那么如果要想将其修改为用户定义对象需要修改以下部分：
· 所有的数据类型应该是用户自定义对象；
· 查询数据和删除数据依靠的是String的equals()方法，这个方法的实际功能是对象比较，那么如果是用户对象，则对象所在的类一定要编写对象比较操作（compare()）；
第一步：定义自己的类，提供好对象比较方法
| class Person { private String name ; private int age ; public Person(String name,int age) { this.name = name ; this.age = age ; } public boolean compare(Person person) { if (this == person) { return true ; } if (person == null) { return false ; } if (this.name.equals(person.name) && this.age == person.age) { return true ; } return false ; } public String getInfo() { return "姓名：" + this.name + "，年龄：" + this.age ; } } |
第二步：修改Link类，此时保存的类型是Person，比较的方法是compare()
| class Link { // 用户最需要关注的是这个类 // Node类不希望被其它类使用，但是Link类要使用 private class Node { // 存储数据和配置节点关系 private Person data ; // 假设现在保存的是String private Node next ; // 下一个节点 public Node(Person data) { // 节点要有数据 this.data = data ; } public void addNode(Node newNode) { if (this.next == null) { // 当前节点的下一个为null this.next = newNode ; } else { this.next.addNode(newNode) ; } } public Person getNode(int index) { if(index == Link.this.foot ++) { // 符合查找索引 return this.data ; // 返回当前节点数据 } else { return this.next.getNode(index) ; } } public boolean containsNode(Person data) { if (data.compare(this.data)) { // 查询数据与当前节点吻合 return true ; } else { if (this.next != null) { return this.next.containsNode(data) ; } else { return false ; } } } public void removeNode(Node previous,Person data) { if(this.data.compare(data)) { // 当前节点满足删除数据 previous.next = this.next ; // 空出当前节点 } else { // 向下继续判断 this.next.removeNode(this,data) ; } } public void toArrayNode() { Link.this.retData[Link.this.foot ++] = this.data ; if (this.next != null) { this.next.toArrayNode() ; } } } // ********************************** private Node root ; // 根节点 private int count ; // 统计个数 private int foot ; // 用于标记索引顺序 private Person [] retData ; // 保存的对象数组 public void add(Person data){ if (data == null) { return ; // 保存的数据不为null } Node newNode = new Node(data) ; // 将数据封装为节点 if (this.root == null) { // 没有根节点 this.root = newNode ; // 新节点作为根节点 } else { // 交给Node类进行处理 this.root.addNode(newNode) ; } this.count ++ ; // 增加个数 } public int size() { return this.count ; } public boolean isEmpty() { return this.count == 0 ; } public void clean() { this.root = null ; // 清空 this.count = 0 ; // 归零 } public Person get(int index) { if (index > this.count) { return null ; } this.foot = 0 ; // 让脚标从0开始 return this.root.getNode(index) ; } public boolean contains(Person data) { if (data == null) { return false ; // 没有查询数据 } return this.root.containsNode(data) ; } public void remove(Person data) { if(this.contains(data)) { // 查找到数据了 if (this.root.data.compare(data)) { this.root = this.root.next ; // 改变根节点 } else { // 要删除的不是根节点 this.root.next.removeNode(this.root,data) ; } this.count -- ; } } public Person [] toArray() { if(this.count == 0) { return null ; // 没数据 } this.foot = 0 ; // 通过foot设置数组索引 this.retData = new Person [this.count] ; // 开辟数组 this.root.toArrayNode() ; // 交给Node类处理 return this.retData ; } } public class LinkDemo { public static void main(String args[]) { Link all = new Link() ; all.add(new Person("张三",20)) ; all.add(new Person("李四",30)) ; all.add(new Person("王五",50)) ; Person temp [] = all.toArray() ; for (int x = 0 ; x < temp.length ; x ++) { System.out.println(temp[x].getInfo()) ; } System.out.println(all.contains(new Person("王五",50))) ; } } |
对于此部分的内容会修改使用即可，不要求从无到有编写。
2、链表习题讲解_A
之所以不再使用对象数组而使用链表进行替代，很大一个关系在于，链表是一种动态的顺序结构，可以实现轻松的数据删除与查询功能，这一点是对象数组所不具备的功能。
0、 利用链表来修改之前的部门和雇员关系（一对多）
1、 多对多映射
配置完关系之后，要求可以实现如下的功能：
· 可以根据一个管理员取得此管理员所在的所有管理员组，以及每个管理员组所具备的权限；
· 可以根据一个管理员组取得此管理员组下的所有管理员和权限信息；
· 可以根据一个权限取得具备此权限的所有管理员组，以及每个管理员组的管理员信息。
那么到现在为止就可以清楚的发现，如果继续按照之前所学习的代码进行项目的编写，最麻烦的莫过于数据的统一问题，就拿链表为例，换一种数据类型就需要去修改链表结构，这种代码是不可使用的。所以后面的内容就是进行参数类型的统一。
本程序只是一个简单的多对多映射。
3、链表习题讲解_B
多对多映射（能理解就理解）
最麻烦的地方在于下载记录，此时的下载记录之中发现存在有多个数据，一个用户有多个下载记录，一个软件有多个下载记录。