Java 链表（映射中使用链表）

范例：一对多映射

//省份类
class Province {
	private int pid;// 省份编号
	private String name;// 省份名称
	private Link cities = new Link();

	public Province(int pid, String name) {
		this.pid = pid;
		this.name = name;
	}

	public boolean compare(Province pro) {
		if (this == pro) {
			return true;
		}
		if (pro == null) {
			return false;
		}
		if (this.name.equals(pro.name) && this.pid == pro.pid) {
			return true;
		}
		return false;
	}

	public Link getCities() {
		return this.cities;
	}

	public String getInfo() {
		return "省份编号：" + this.pid + "，名称：" + this.name + "。";
	}

}

// 城市类
class City {
	private int cid;// 城市编号
	private String name;// 城市名称
	private Province pro;

	public City(int cid, String name) {
		this.cid = cid;
		this.name = name;
	}

	public boolean compare(City city) {
		if (this == city) {
			return true;
		}
		if (city == null) {
			return false;
		}
		if (this.cid == city.cid && this.name.equals(city.name)) {
			return true;
		}
		return false;
	}

	public void setProvince(Province pro) {
		this.pro = pro;
	}

	public Province getProvince() {
		return this.pro;
	}

	public String getInfo() {
		return "城市编号：" + this.cid + "城市名称：" + this.name + "。";
	}
}

// 链表类
class Link {
	class Node {// 定义节点类
		private Node next;// 引用关系
		private City data;// 保存数据

		// 构造方法
		public Node(City data) {
			this.data = data;
		}

		// 1.添加节点
		public void addNode(Node newNode) {
			if (this.next == null) {// 当前节点的下一个节点为空
				this.next = newNode;
			} else {// 向后继续保存
				this.next.addNode(newNode);
			}
		}

		// 2.查询数据
		public boolean containsNode(City data) {
			if (data.compare(this.data)) {// 当前节点数据为要查询的数据
				return true;// 后面不在需要查询
			} else {// 当前节点不能满足查询
				if (this.next != null) {// 判断后续是否还有节点
					return this.next.containsNode(data);
				} else {// 没后后续节点
					return false;
				}
			}
		}

		// 3.数据修改
		public void setNode(int index, City data) {
			// 使用自定义foot内容与 index比较
			if (Link.this.foot++ == index) {
				this.data = data;// 进行内容修改
			} else {// 继续
				this.next.setNode(index, data);
			}
		}

		// 4.获取数据
		public City getNode(int index) {
			// 使用自定义foot内容与 index比较
			// foot自增，目的为下一次查询方便
			if (Link.this.foot++ == index) {// 要查询的索引
				return this.data;// 返回当前节点数据
			} else {// 继续向后查
				return this.next.getNode(index);
			}
		}

		// 5.删除数据
		public void removeNode(Node previous, City data) {
			if (data.compare(this.data)) {// 数据对应
				previous.next = this.next;// 空出当前节点
			} else {// 继续向后查询
				this.next.removeNode(this, data);
			}
		}

		// 6.对象数组
		public void toArrayNode() {
			Link.this.retArray[Link.this.foot++] = this.data;
			if (this.next != null) {// 后续还有元素
				this.next.toArrayNode();
			}
		}
	}

	// ================以上为内部类================
	private Node root;// 根节点
	private int count = 0;// 保存元素个数
	private int foot = 0;
	private City[] retArray;// 返回数组

	// 1.添加数据
	public void add(City data) {
		if (data == null) {// 数据不允许为null
			return;
		}
		Node newNode = new Node(data);// 保存数据，数据打包
		if (this.root == null) {// 当前没有根节点
			this.root = newNode;// 新节点为根节点
		} else {// 根节点存在，其它节点给Node处理
			this.root.addNode(newNode);
		}
		this.count++;// 每次保存成功后自增一次
	}

	// 2.查询数据
	public boolean contains(City data) {
		if (data == null || this.root == null) {// 没有数据，根节点也没有数据
			return false;
		}
		return this.root.containsNode(data);
	}

	// 3.修改数据
	public void set(int index, City data) {
		if (index > this.count) {
			return;
		}
		this.foot = 0;// 归零，从头向后开始
		this.root.setNode(index, data);// 修改过程交给Node
	}

	// 4.获取数据
	public City get(int index) {
		if (index > this.count) {// 超出查询范围
			return null;
		}
		this.foot = 0;// 归零，从头向后开始
		return this.root.getNode(index);// 查询过程交给Node
	}

	// 5.删除数据
	public void remove(City data) {
		if (this.contains(data)) {// 1.先判断是否存在此数据
			// 2.判断删除的数据是否根节点数据
			// 3.root是Node的对象，此处直接访问内部类的私有操作
			if (data.compare(this.root.data)) {// 根节点是否满足删除
				this.root = this.root.next;// 空出当前节点
			} else {// 不是根节点
				// 根节点的下一个节点开始判断
				this.root.next.removeNode(this.root, data);
			}
			this.count--;// 删除成功后自减
		}
	}

	// 6.链表长度
	public int length() {
		return this.count;
	}

	// 7.链表是否为空
	public boolean isEmpty() {
		return this.count == 0;
	}

	// 8.对象数组
	public City[] toArray() {
		if (this.root == null) {
			return null;
		}
		this.foot = 0;
		this.retArray = new City[this.count];// 开辟数组
		this.root.toArrayNode();
		return this.retArray;
	}

	// 打印方法
	public static void print(City[] data) {
		for (City x : data) {
			System.out.println(x.getInfo() + " ");
		}
		System.out.println();
	}

}

public class Demo02 {
	public static void main(String[] args) {
		// 1.实例化关系对象
		Province pro = new Province(44, "广东省");
		City c1 = new City(5810, "广州");
		City c2 = new City(5840, "深圳");
		City c3 = new City(5950, "惠州");
		// 2.设置关系
		c1.setProvince(pro);
		c2.setProvince(pro);
		c3.setProvince(pro);
		pro.getCities().add(c1);
		pro.getCities().add(c2);
		pro.getCities().add(c3);
		// 3.取出关系
		System.out.println(pro.getInfo());
		System.out.println("拥有的城市数量:" + pro.getCities().length());
		City[] city = pro.getCities().toArray();
		Link.print(city);
	}
}