多个字串包含关系生成树形结构

 需要生成结构如下

代码搞起

package com;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;

import org.hibernate.type.PrimitiveByteArrayBlobType;

import com.alibaba.fastjson.JSONObject;
import com.sun.javafx.collections.MappingChange.Map;
import com.sun.org.apache.xerces.internal.xs.ShortList;

public class Test {
	private static List<String> list=new ArrayList<>();
	static {
		list.add("你好");
		list.add("你好呀！");
		list.add("你好吗？");
		list.add("你好呀！你在干嘛？");
		list.add("你好呀！你在干嘛？你");
		list.add("你");
		list.add("你在干嘛？");
		list.add("玩过扑克的都知道，玩扑克的一些顺序，首先要有牌，然后洗牌，然后");
		list.add("玩过扑克的都知道，玩扑克的一些顺序，首先要有牌，然后洗牌，后");
		list.add("玩过扑克的都知道，玩扑克的一些顺序，牌，然后洗牌，后");
		list.add("玩过扑克的都知道，玩克的一些顺序，牌，然后洗牌，后");
		list.add("扑克的都知道，玩克的一些顺序，牌，然后洗牌，后");
		list.add("扑克的都知道，玩克的一些顺序，牌，然后洗牌，");
		list.add("扑克的都知道，玩克的一些顺序，牌，");
		list.add("扑克的都知道，");
		list.add("扑克都知道，");
		list.add("知道，");
		list.add("知");
		list.add("，");
	}
	public static void getNode(HashMap<Node,List<String>> nodeMap) {
		for (Entry<Node, List<String>> entry : nodeMap.entrySet()) {
			Node node = entry.getKey();
			List<String> valueList = entry.getValue();
			List<String> removeStrList=new ArrayList<>();
			HashMap<Node,List<String>> newMap = new HashMap<Node,List<String>>();
			for (String var : valueList) {
				if(removeStrList.contains(var))
					continue;
				Node node2 = new Node(new ArrayList<Node>(), var);
				node.getNodeList().add(node2);
				List<String> newValues=new ArrayList<>();
				newMap.put(node2, newValues);
				for (String var2 : valueList) {
					if(!var2.equals(var)&&var.contains(var2)) {
						removeStrList.add(var2);
						newValues.add(var2);
					}
				}
			}
			List<Node> nodeList = node.getNodeList();
			for (Node node2 : nodeList) {
				List<String> list2 = newMap.get(node2);
				HashMap<Node,List<String>> tmpMap = new HashMap<Node,List<String>>();
				tmpMap.put(node2, list2);
					getNode(tmpMap);
			}
		}
	}
	public static void main(String[] args) {
		long currentTimeMillis = System.currentTimeMillis();
		HashMap<Node,List<String>> hashMap = new HashMap<Node,List<String>>();
		Node node = new Node(new ArrayList<Node>(), null);
		list.sort(new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return -Integer.compare(o1.length(),o2.length());
			}
		});
		hashMap.put(node, list);
		getNode(hashMap);
		System.out.println(System.currentTimeMillis()-currentTimeMillis);
		System.out.println(JSONObject.toJSONString(node));
	}
}
class Node{
	private List<Node> nodeList;
	private String nodeValue;
	public Node(List<Node> nodeList, String nodeValue) {
		super();
		this.nodeList = nodeList;
		this.nodeValue = nodeValue;
	}
	public List<Node> getNodeList() {
		return nodeList;
	}
	public void setNodeList(List<Node> nodeList) {
		this.nodeList = nodeList;
	}
	public String getNodeValue() {
		return nodeValue;
	}
	public void setNodeValue(String nodeValue) {
		this.nodeValue = nodeValue;
	}
	@Override
	public String toString() {
		return "Node [nodeList=" + nodeList + ", nodeValue=" + nodeValue + "]";
	}
	
}

方法二：

package com;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.apache.commons.lang.StringUtils;

import com.alibaba.fastjson.JSON;

public class Test2 {
	private static List<String> list=new ArrayList<>();
	static {
		list.add("你好");
		list.add("你好呀！");
		list.add("你好吗？");
		list.add("你好呀！你在干嘛？");
		list.add("你好呀！你在干嘛？你");
		list.add("你");
		list.add("你在干嘛？");
		list.add("玩过扑克的都知道，玩扑克的一些顺序，首先要有牌，然后洗牌，然后");
		list.add("玩过扑克的都知道，玩扑克的一些顺序，首先要有牌，然后洗牌，后");
		list.add("玩过扑克的都知道，玩扑克的一些顺序，牌，然后洗牌，后");
		list.add("玩过扑克的都知道，玩克的一些顺序，牌，然后洗牌，后");
		list.add("扑克的都知道，玩克的一些顺序，牌，然后洗牌，后");
		list.add("扑克的都知道，玩克的一些顺序，牌，然后洗牌，");
		list.add("扑克的都知道，玩克的一些顺序，牌，");
		list.add("扑克的都知道，");
		list.add("扑克都知道，");
		list.add("知道，");
		list.add("知");
		list.add("，");
	}
	  public static void main(String[] args) {
//	        Collections.shuffle(list);
		  long currentTimeMillis = System.currentTimeMillis();
	        Node root = new Node("");
	        list.sort(new Comparator<String>() {
				@Override
				public int compare(String o1, String o2) {
					return Integer.compare(o1.length(),o2.length());
				}
			});
	        for(String str:list){
	            Node.insertNode(root,str);
	        }
	        System.out.println(System.currentTimeMillis()-currentTimeMillis);
	        System.out.println(JSON.toJSONString(root));
	    }
	static class Node{
		private String val;
		private List<Node> subNodes;
		
		public Node(String val){
			this.val = val;
		}
		public static void insertNode(Node node, String val){
	        if(StringUtils.isEmpty(val)){
	            return;
	        }
	        if(node.getSubNodes().size() == 0){
	            Node nNode = new Node(val);
	            node.getSubNodes().add(nNode);
	            return;
	        }
	        boolean isContain = false;
	        for(int i = node.getSubNodes().size() - 1;i >= 0;i--){
	            if(node.getSubNodes().get(i).getVal().contains(val)){  //val被包含
	                isContain = true;
	                Node nNode = new Node(val);
	                Node curNode = node.getSubNodes().get(i);
	                node.getSubNodes().set(i,nNode);
	                nNode.getSubNodes().add(curNode);
	            }else if(val.contains(node.getSubNodes().get(i).getVal())){ //val包含
	                isContain = true;
	                insertNode(node.getSubNodes().get(i),val);
	            }
	        }
	        if(!isContain){
	            Node nNode = new Node(val);
	            node.getSubNodes().add(nNode);
	        }
	    }
		
		public String getVal() {
			return val;
		}
		
		public void setVal(String val) {
			this.val = val;
		}
		
		public List<Node> getSubNodes() {
			if(this.subNodes == null){
				this.subNodes = new ArrayList<Node>();
			}
			return subNodes;
		}
		
		public void setSubNodes(List<Node> subNodes) {
			this.subNodes = subNodes;
		}
		
		@Override
		public String toString() {
			return "Node{" + "val='" + val + '\'' + '}';
		}
}
}

方法三：

package com;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.annotation.JSONField;
import com.alibaba.fastjson.serializer.SerializerFeature;

public class Logic {
	public static String handleStructure(List<String> nodeStringList) {
		List<LogicEntity> nodeList = new ArrayList<LogicEntity>();
		LogicEntity root = new LogicEntity("");
		//去重
		Set<String> nodeStringSet = new HashSet<String>(nodeStringList);
		for (String nodeString : nodeStringSet) {
			LogicEntity node = new LogicEntity(nodeString);
			nodeList.add(node);
		}
//		Collections.sort(nodeList);
		nodeList.sort(new Comparator<LogicEntity>() {
			@Override
			public int compare(LogicEntity o1, LogicEntity o2) {
				return o1.getValue().length()-o2.getValue().length();
			}
		});
		while(true) {
			if(0==nodeList.size()) {
				break;
			}
			LogicEntity node = nodeList.remove(0);
			boolean isRootChild = true;
			for (LogicEntity other : nodeList) {
				String ov = other.getValue();
				String nv = node.getValue();
				if(0<=ov.indexOf(nv)) {
					if(ov.length()!=nv.length() && !node.containFather(ov)) {
						other.addChild(node);
						node.addFather(other);
					}
					isRootChild = false;
				}
			}
			if(isRootChild) {
				root.addChild(node);
			}
		}
		return JSONObject.toJSONString(root.getChilds(),SerializerFeature.DisableCircularReferenceDetect);
	}
	
	public static void main(String[] args) {
		List<String> nodeList = new ArrayList<String>();
		nodeList.add("他");
		nodeList.add("他的");
		nodeList.add("他的钱");
		nodeList.add("他的钱包");
		nodeList.add("他的钥匙");
		nodeList.add("他的手机");
		nodeList.add("他的手");
		nodeList.add("他的手表");
		nodeList.add("他的手表丢了");
		nodeList.add("他的手表丢了没找到");
		nodeList.add("他的手表丢了没找到怎么办");
		nodeList.add("手表");
		nodeList.add("手机");
		nodeList.add("手");
		System.out.println(handleStructure(nodeList));
	}
	
}
class LogicEntity implements Comparable<LogicEntity> {
	private String value = "";
	private List<LogicEntity> childs = new ArrayList<LogicEntity>();
	@JSONField(serialize=false)  
	private List<LogicEntity> fathers = new ArrayList<LogicEntity>();

	public LogicEntity(String value) {
		this.value = value;
	}

	public List<LogicEntity> getChilds() {
		return childs;
	}
	
	public List<LogicEntity> getFathers() {
		return childs;
	}

	public void addChild(LogicEntity child) {
		this.childs.add(child);
	}
	
	public void addFather(LogicEntity father) {
		this.fathers.add(father);
	}

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}
	
	public boolean containFather(String value) {
		for (LogicEntity father : fathers) {
			if(0<=value.indexOf(father.value)) {
				return true;
			}
		}
		return false;
	}

	public String toString(String t) {
		StringBuffer childStr = new StringBuffer();
		for (LogicEntity child : childs) {
			childStr.append(child.toString(t+"\t"));
		}
		return (0>=childStr.length())?t+value+"\n":t+value+":"+"{\n"+childStr+t+"}\n";
	}

	@Override
	public int compareTo(LogicEntity o) {
		return this.getValue().length()-o.getValue().length();
	}
	
}