devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java学习笔记第六周（一）_import java.util.arrays; import java.util.emptysta

作者：羊村懒王 | 2024-03-06 22:46:41

赞

踩

import java.util.arrays; import java.util.emptystackexception; public class

目录

数据结构专项

一、数据结构简介

1、什么是数据结构

2、数据结构逻辑分类

二、线性结构

1 栈结构

1.1 栈的定义

1.2 实现自定义栈容器

2、链表结构

2.1 链表结构的定义

2.2  单向链表结构

 2.3 实现单向链表

2.4 双向链表结构

 2.5 实现双向链表

三、树形结构

1、树形结构简介

2、树的相关术语

3、二叉树简介

3.1二叉树分类

4、二叉树遍历

4.1 前序遍历

 4.2 中序遍历

​4.3 后序遍历

 4.4 层序遍历

5、二叉树排序

5.1 二叉树排序分析

5.2 二叉树排序实现

6、自定义树形结构容器

6.1 树形结构定义

6.2 实现自定义树形结构容器

数据结构专项

一、数据结构简介

1、什么是数据结构

简单地说，数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定了数据结构对于某些操作是高效的，而对于其他操作则是低效的。所以我们需要理解各种数据结构，才能在处理实际问题时选取最合适的数据结构。

数据结构=逻辑结构+物理结构（顺序、链式、索引、散列）

逻辑结构：数据元素间抽象化的相互关系

物理结构：（存储结构），在计算机存储器中的存储形式

 

2、数据结构逻辑分类

二、线性结构

1 栈结构

1.1 栈的定义

栈是一种只能从一端存取数据且遵循"后进先出(LIFO)"原则的线性存储结构。

1.2 实现自定义栈容器

  1. package studyweek6数据结构;
  2.  
  3. import java.util.Arrays;
  4. import java.util.EmptyStackException;
  5.  
  6. /**
  7.  * 自定义栈容器
  8.  */
  9. public class MyStack<E> {
  10.     private Object[] arr;//存放元素的物理结构
  11.  
  12.     private int stackLength=4;//数组的默认长度
  13.  
  14.     private int size; //记录栈容器的元素个数
  15.  
  16.     private int index=-1; //操作数组下标位置的指针
  17.  
  18.     /**判断栈容器是否为空
  19.      *
  20.      * @return
  21.      */
  22.     public boolean empty(){
  23.         return this.size==0;
  24.     }
  25.  
  26.     /**
  27.      * 获取栈顶元素
  28.      * @return
  29.      */
  30.     public E pop(){
  31.         //如果栈容器中没有元素，则抛出异常
  32.         if(this.index==-1){
  33.             throw new EmptyStackException();
  34.         }
  35.  
  36.         //拿出元素后要记录元素个数
  37.         this.size--;
  38.         //如果有元素，则返回栈顶元素
  39.         return (E)this.arr[index--];
  40.     }
  41.  
  42.     /**
  43.      * 向栈容器中添加元素
  44.      * @param item
  45.      * @return
  46.      */
  47.     public E push(E item){
  48.         //初始化数组
  49.         this.capacity();
  50.  
  51.         //向数组中添加元素
  52.         this.arr[++index]=item;//index先+1得到下标0，再添加
  53.  
  54.         //记录元素个数
  55.         this.size++;
  56.         return item;
  57.     }
  58.  
  59.     /**
  60.      * 数组初始化或者以1.5倍容量对数组扩容
  61.      */
  62.     private void capacity(){
  63.         //数组初始化
  64.         if(this.arr==null){
  65.             this.arr=new Object[this.stackLength];
  66.         }
  67.  
  68.         //以1.5倍对数组扩容
  69.         if(this.size-(this.stackLength-1)>=0){
  70.             this.stackLength=this.stackLength+(this.stackLength>>1);
  71.             this.arr= Arrays.copyOf(this.arr,this.stackLength);//扩容操作是创建新的数组，并且把原数组拷贝到更大的数组里，copyOf()可以一次性实现，第一个参数是要扩容的原数组，第二哥参数是要扩容的长度
  72.         }
  73.  
  74.     }
  75.  
  76.     //自定义栈容器的测试
  77.     public static void main(String[] args) {
  78.         //实例化容器哦
  79.         MyStack<String> myStack=new MyStack<>();
  80.         myStack.push("a");
  81.         myStack.push("b");
  82.         myStack.push("c");
  83.         myStack.push("d");
  84.         myStack.push("e");
  85.         myStack.push("f");
  86.         System.out.println(myStack.size);
  87.         System.out.println(myStack.pop());
  88.         System.out.println(myStack.pop());
  89.         System.out.println(myStack.pop());
  90.  
  91.     }
  92.  
  93. }

2、链表结构

2.1 链表结构的定义

 

2.2  单向链表结构

 2.3 实现单向链表

创建链表接口：

  1. package studyweek6数据结构;
  2.  
  3. /**
  4.  * 创建链表结构，让单向链表和双向链表实现该接口即可
  5.  *基于链表结构存取元素的方法API定义
  6.  * @param <E>
  7.  */
  8. public interface MyList<E> {
  9.     void add(E element);
  10.     E get(int index);
  11.     int size();
  12.     E remove(int index);
  13. }

  1. package studyweek6数据结构;
  2.  
  3.  
  4. /**
  5.  * 基于单向链表实现元素存取的容器
  6.  * @param <E>
  7.  */
  8.  
  9. public class MySinglyLinkedList<E> implements MyList<E> {
  10.  
  11.     /**
  12.      * 定于单向链表的节点对象（使用节点内部类来实现）
  13.      */
  14.     class Node<E>{
  15.         private E item;//存储元素
  16.         private Node next;//存储下一个节点对象的成员变量的的地址
  17.  
  18.         Node(E item,Node next){
  19.             this.item=item;
  20.             this.next=next;
  21.         }
  22.     }
  23.  
  24.     private Node head;//存放链表中的头节点（第一个节点）
  25.     private int size;//记录元素的个数
  26.  
  27.     /**
  28.      * 向链表中添加元素
  29.      * @param element
  30.      */
  31.     @Override
  32.     public void add(E element) {
  33.         //创建节点
  34.         Node<E> node=new Node<>(element,null);
  35.         //找到尾节点
  36.         Node tail=getTail();
  37.         //节点的挂接
  38.         if(tail==null){
  39.             this.head=node;
  40.         }else{
  41.             tail.next=node;
  42.         }
  43.         //记录元素个数
  44.         this.size++;
  45.     }
  46.  
  47.     /**
  48.      * 找尾节点
  49.      */
  50.     private Node getTail(){
  51.         //判断头节点是否存在
  52.         if(this.head==null){
  53.             return null;
  54.         }
  55.  
  56.         //查找尾节点
  57.         Node node=this.head;
  58.         while(true){
  59.             if(node.next==null)break;
  60.             node=node.next;
  61.         }
  62.         return node;
  63.     }
  64.  
  65.  
  66.  
  67.     /**
  68.      * 根据元素的位置获取元素
  69.      * @param index
  70.      * @return
  71.      */
  72.     @Override
  73.     public E get(int index) {
  74.         //校验Index的合法性
  75.         this.checkIndex(index);
  76.         //根据位置获取指定字节
  77.         Node<E> node=this.getNode(index);
  78.         //返回该节点中的元素
  79.         return node.item;
  80.     }
  81.     /**
  82.      * 对index合法性进行校验
  83.      */
  84.     private void checkIndex(int index){
  85.         if(!(index>=0&&index<this.size)){
  86.             throw new IndexOutOfBoundsException("Index:"+index+"Size"+this.size);
  87.         }
  88.     }
  89.     /**
  90.      * 根据位置获取节点
  91.      */
  92.     private Node getNode(int index){
  93.         Node<E> node=this.head;
  94.         for(int i=0;i<index;i++){
  95.             node=node.next;
  96.         }
  97.         return node;
  98.     }
  99.  
  100.  
  101.  
  102.     /**
  103.      * 获取元素个数的方法
  104.      * @return
  105.      */
  106.     @Override
  107.     public int size() {
  108.         return this.size;
  109.     }
  110.  
  111.  
  112.     /**
  113.      * 根据元素的位置删除元素
  114.      * @param index
  115.      * @return
  116.      */
  117.     @Override
  118.     public E remove(int index) {
  119.         //校验Index的合法性
  120.         this.checkIndex(index);
  121.         //根据位置找到该节点对象
  122.         Node<E> node=this.getNode(index);
  123.         //获取该节点对象的元素
  124.         E item=node.item;
  125.         //删除该节点对象
  126.             //判断当前删除的节点是否为头节点
  127.         if(this.head==node){
  128.             this.head=node.next;
  129.         }else{
  130.            Node<E> temp=this.head;
  131.            for(int i=0;i<index-1;i++){
  132.                temp=temp.next;//temp会循环到node前一个节点
  133.            }
  134.            temp.next=node.next;//node前一个节点的下一个节点指向node的下一个节点，这样就可以跳过node节点
  135.         }
  136.         node.next=null;
  137.         //记录元素个数
  138.         this.size--;
  139.         //将被删除的元素返回
  140.         return item;
  141.     }
  142.  
  143.     public static void main(String[] args) {
  144.         MySinglyLinkedList<String> mySinglyLinkedList=new MySinglyLinkedList<>();
  145.         mySinglyLinkedList.add("a");
  146.         mySinglyLinkedList.add("b");
  147.         mySinglyLinkedList.add("c");
  148.         mySinglyLinkedList.add("d");
  149.         System.out.println(mySinglyLinkedList.size());
  150.         System.out.println(mySinglyLinkedList.remove(0));
  151.         for(int i=0;i< mySinglyLinkedList.size;i++){
  152.             System.out.println(mySinglyLinkedList.get(i));
  153.         }
  154.  
  155.     }
  156. }

2.4 双向链表结构

 

 2.5 实现双向链表

  1. package studyweek6数据结构;
  2.  
  3. public class MyDoublyLinkedLIst<E> implements MyList<E>{
  4.     /**
  5.      * 定义双向链表的节点对象
  6.      */
  7.     class Node<E>{
  8.         E item;//记录元素
  9.         Node<E> prev;//记录前一个节点对象
  10.         Node<E> next;//记录下一个节点对象
  11.         Node(Node<E> prev,E item,Node<E> next){
  12.             this.item=item;
  13.             this.next=next;
  14.             this.prev=prev;
  15.         }
  16.     }
  17.  
  18.  
  19.     private Node head;//记录头节点
  20.     private Node tail;//记录尾节点
  21.     private int size;//记录元素个数
  22.     /**
  23.      * 向双向链表中添加元素
  24.      * @param element
  25.      */
  26.     @Override
  27.     public void add(E element) {
  28.         this.linkLast(element);
  29.     }
  30.     /**
  31.      * 将节点对象添加到双向链表的尾部
  32.      */
  33.     private void linkLast(E element){
  34.         //获取尾节点
  35.         Node t=this.tail;
  36.         //创建节点对象
  37.         Node<E> node=new Node<>(t,element,null);
  38.         //将新节点定义为尾节点
  39.         this.tail=node;
  40.         if(t==null){
  41.             this.head=node;
  42.         }else{
  43.             t.next=node;
  44.         }
  45.         this.size++;
  46.     }
  47.  
  48.  
  49.  
  50.     /**
  51.      * 根据指定位置获取元素
  52.      * @param index
  53.      * @return
  54.      */
  55.     @Override
  56.     public E get(int index) {
  57.         //Index合法性检验
  58.         this.checkIndex(index);
  59.         //根据位置获取指定节点对象
  60.         Node<E> node=this.getNode(index);
  61.         return node.item;
  62.     }
  63.     /**
  64.      * 校验Index的合法性
  65.      */
  66.     private void checkIndex(int index){
  67.         if(!(index>=0&&index<this.size)){
  68.             throw new IndexOutOfBoundsException("Index"+index+"Size"+size);
  69.         }
  70.     }
  71.     /**
  72.      * 根据位置获取指定节点对象
  73.      */
  74.     private Node getNode(int index){
  75.         //由于双向链表可以往任意一边开始查找，因此可以先判断当前位置距离头或者尾节点哪个更近
  76.         if(index<(this.size>>1)){
  77.             Node node=this.head;
  78.             for(int i=0;i<index;i++){
  79.                 node=node.next;//移动node指针
  80.             }
  81.             return node;
  82.         }else{
  83.             Node node=this.tail;
  84.             for(int i=this.size-1;i>index;i--){
  85.                 node=node.prev;
  86.             }
  87.             return node;
  88.         }
  89.     }
  90.  
  91.  
  92.     /**
  93.      * 返回元素个数
  94.      * @return
  95.      */
  96.     @Override
  97.     public int size() {
  98.         return this.size;
  99.     }
  100.  
  101.  
  102.     /**
  103.      * 根据指定位置删除元素
  104.      * @param index
  105.      * @return
  106.      */
  107.     @Override
  108.     public E remove(int index) {
  109.         //对index进行合法性校验
  110.         this.checkIndex(index);
  111.         //根据指定位置获取节点对象
  112.         Node<E> node=this.getNode(index);
  113.         //获取节点对象中的元素
  114.         E item=node.item;
  115.         //判断当前节点是否为头节点
  116.         if(node.prev==null){//头节点的prev为空
  117.             this.head=node.next;
  118.         }else{
  119.             //完成当前节点的直接前驱节点与当前节点的直接后继节点的挂接
  120.             node.prev.next=node.next;
  121.         }
  122.         //判断当前节点是否为尾节点
  123.         if(node.next==null){
  124.             this.tail=node.prev;
  125.         }else{
  126.             //完成当前节点的直接后继节点与当前节点的直接前驱节点的挂接
  127.             node.next.prev=node.prev;
  128.         }
  129.  
  130.         //移除出链表
  131.         node.prev=null;
  132.         node.next=null;
  133.         node.item=null;
  134.         this.size--;
  135.         return item;
  136.     }
  137.  
  138.     /**
  139.      * 在双向链表的头添加元素
  140.      */
  141.     public void addFirst(E element){
  142.         this.linkFirst(element);
  143.     }
  144.     private void linkFirst(E element){
  145.         Node head=this.head;
  146.         Node node=new Node<>(null,element,head);
  147.         //将新节点定义为头节点
  148.         this.head=node;
  149.         //判断当前链表中是否有节点，如果没有，那么该节点既是头也是尾节点
  150.         if(head==null){
  151.             this.tail=node;
  152.         }else{
  153.             head.prev=node;
  154.         }
  155.         this.size++;
  156.     }
  157.  
  158.     /**
  159.      * 在双向链表的尾添加元素
  160.      */
  161.     public void addLast(E element){
  162.         this.linkLast(element);
  163.     }
  164.  
  165.  
  166.  
  167.     //测试
  168.     public static void main(String[] args) {
  169.         /*MyList<String> myList=new MyDoublyLinkedLIst<>();
  170.         myList.add("a");
  171.         myList.add("b");
  172.         myList.add("c");
  173.         myList.add("d");
  174.         System.out.println(myList.remove(2));
  175.         System.out.println(myList.size());
  176.         for(int i=0;i<myList.size();i++){
  177.             System.out.println(myList.get(i));
  178.         }*/
  179.  
  180.         //由于新建的addFirst和addLast方法没有在接口里定义，因此想要使用，引用必须是 MyDoublyLinkedLIst类型
  181.         MyDoublyLinkedLIst<String> list=new MyDoublyLinkedLIst<>();
  182.         list.add("a");
  183.         list.addFirst("A");
  184.         list.addLast("B");
  185.         for(int i=0;i<list.size();i++){
  186.             System.out.println(list.get(i));
  187.         }
  188.     }
  189. }

三、树形结构

1、树形结构简介

2、树的相关术语

 

 

3、二叉树简介

        二叉树（BinaryTree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分。

3.1二叉树分类

满二叉树：满二叉树指除最后一层外，每一层上的所有节点都有两个子节点。

完全二叉树：完全二叉树，除最后一层可能不满以外，其他各层都达到该层节点的最大数，最后一层如果不满，该层所有节点都全部靠左排。

 

4、二叉树遍历

二叉树遍历的方式：

前序遍历：根-左-右

中序遍历：左-根-右

后序遍历：左-右-根

层序遍历：从上至下逐层遍历

4.1 前序遍历

 4.2 中序遍历

4.3 后序遍历

 4.4 层序遍历

 

5、二叉树排序

5.1 二叉树排序分析

 

5.2 二叉树排序实现

  1. package studyweek6数据结构;
  2.  
  3. /**
  4.  * 基于二叉树结构实现元素排序处理
  5.  */
  6. public class BinaryTreeSort<E extends Integer>{//目前先实现整数的排序处理
  7.     /**
  8.      * 定义结点类
  9.      */
  10.     class Node<E extends Integer> {
  11.         private E item;//存放元素
  12.         private Node left;//存放左子树地址
  13.         private Node right;//存放右子树地址
  14.         Node(E item){
  15.             this.item=item;
  16.         }
  17.         /**
  18.          * 添加结点
  19.          */
  20.         public void addNode(Node node) {
  21.             //完成新结点中的元素与当前结点中的元素的判断
  22.             //如果新结点中的元素小于当前结点中的元素，那么新结点则放到当前结点的左子树中
  23.             if (node.item.intValue() < this.item.intValue()) {
  24.                 if (this.left == null) {
  25.                     this.left = node;
  26.                 } else {
  27.                     this.left.addNode(node);//递归判断
  28.                 }
  29.  
  30.             }
  31.             //如果新结点中的元素小于当前结点中的元素，那么新结点则放到当前结点的左子树中
  32.             else {
  33.                 if(this.right==null){
  34.                     this.right=node;
  35.                 }
  36.                 else{
  37.                     this.right.addNode(node);
  38.                 }
  39.             }
  40.         }
  41.  
  42.         /**
  43.          * 使用中序遍历二叉树
  44.          */
  45.         public void inorderTraversal(){
  46.             //找到最左侧的那个结点
  47.             if(this.left!=null){
  48.                 this.left.inorderTraversal();
  49.             }
  50.             System.out.println(this.item);
  51.             if(this.right!=null){
  52.                 this.right.inorderTraversal();
  53.             }
  54.  
  55.         }
  56.     }
  57.  
  58.  
  59.  
  60.     /**
  61.      * 将元素添加到排序器中
  62.      */
  63.     private Node root;//存放数的根结点的地址
  64.     public void add(E element){
  65.         //实例化结点对象
  66.         Node<E> node=new Node<>(element);
  67.         //判断当前二叉树中是否有根结点。如果没有那么新结点就是根结点
  68.         if(this.root==null){
  69.             this.root=node;
  70.         }else{
  71.             this.root.addNode(node);
  72.         }
  73.  
  74.     }
  75.  
  76.  
  77.     /**
  78.      * 对元素进行排序
  79.      */
  80.     public void sort(){
  81.         //判断根结点是否为空
  82.         if(this.root==null)return;
  83.         this.root.inorderTraversal();
  84.     }
  85.  
  86.  
  87.     //测试
  88.     public static void main(String[] args) {
  89.         BinaryTreeSort<Integer> sort=new BinaryTreeSort<>();
  90.         //8,1,3,9,4,5
  91.         sort.add(8);
  92.         sort.add(1);
  93.         sort.add(3);
  94.         sort.add(9);
  95.         sort.add(4);
  96.         sort.add(5);
  97.         sort.sort();
  98.     }
  99. }

6、自定义树形结构容器

6.1 树形结构定义

 

6.2 实现自定义树形结构容器

  1. package studyweek6数据结构;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  7.  
  8. /**
  9.  * 基于树形结构实现元素的储存器
  10.  */
  11.  
  12. public class MyTree <E>{
  13.     private Map<E,E> map=new HashMap<>();//String->String
  14.     private Map<E,List<E>> map2=new HashMap<>(); //String->List
  15.  
  16.     /**
  17.      * 向容器中添加元素
  18.      */
  19.      public void add(E parent,E item){
  20.          //完成单结点之间的映射
  21.          this.map.put(item,parent);
  22.          //完成多结点之间的映射
  23.          List<E> list =this.map2.get(parent);
  24.          if(list==null){
  25.              list=new ArrayList<>();
  26.              this.map2.put(parent,list);
  27.          }
  28.          list.add(item);
  29.      }
  30.  
  31.  
  32.     /**
  33.      * 获取当前结点的父结点
  34.      */
  35.     public E getParent(E item){
  36.         return this.map.get(item);
  37.     }
  38.  
  39.  
  40.     /**
  41.      * 获取当前结点的子结点
  42.      */
  43.      public List<E> getChild(E item){
  44.          return this.map2.get(item);
  45.      }
  46.  
  47.  
  48.     /**
  49.      * 获取当前结点的兄弟结点
  50.      */
  51.     public List<E> getBrother(E item){
  52.         //获取当前结点的父结点
  53.         E parent=this.getParent(item);
  54.         //获取当前父结点的所有子结点
  55.         List<E> list=this.getChild(parent);
  56.         List<E> brother=new ArrayList<>();//不能直接删除list里面的该结点，不然下面所有的子结点会丢失
  57.         if(list!=null){
  58.             brother.addAll(list);
  59.             brother.remove(item);
  60.         }
  61.         return brother;
  62.     }
  63.  
  64.  
  65.     /**
  66.      * 获取当前结点的祖先结点
  67.      */
  68.      public List<E> getForefathers(E item){
  69.          //获取当前结点的父结点
  70.          E parent=this.getParent(item);
  71.          //结束递归的边界条件
  72.          if(parent==null){
  73.              return new ArrayList<>();
  74.          }
  75.          //递归调用，再次获取当前结点的父结点的父结点
  76.          List <E> list=this.getForefathers(parent);//这里的list是当递归结束后会创建一个List去接受所得到的父节点的返回值
  77.          //将递归到的所有结点元素添加到返回的List中
  78.          list.add(parent);//弹栈时再执行
  79.          return list;
  80.      }
  81.  
  82.  
  83.     /**
  84.      * 获取当前结点的子孙结点
  85.      */
  86.      public List<E> getGrandChildren(E item){
  87.          //存放所有子孙结点中的元素
  88.          List<E> list=new ArrayList<>();
  89.          //获取当前结点的子结点
  90.          List<E> child=this.getChild(item);
  91.          //结束递归的边界条件
  92.          if(child==null){
  93.              return list;
  94.          }
  95.          //遍历子结点
  96.          for(int i=0;i<child.size();i++){
  97.              //获取结点中的元素
  98.              E ele=child.get(i);
  99.              //递归调用
  100.              List<E> temp=this.getGrandChildren(ele);
  101.              list.add(ele);
  102.              list.addAll(temp);
  103.          }
  104.          return list;
  105.      }
  106.  
  107.  
  108.     public static void main(String[] args) {
  109.          //实例化容器
  110.         MyTree<String> myTree=new MyTree<>();
  111.         //添加元素
  112.         myTree.add("root","生物");
  113.         myTree.add("生物","植物");
  114.         myTree.add("生物","动物");
  115.         myTree.add("生物","菌类");
  116.         myTree.add("动物","脊椎动物");
  117.         myTree.add("动物","脊索动物");
  118.         myTree.add("动物","腔肠动物");
  119.         myTree.add("脊椎动物","哺乳动物");
  120.         myTree.add("脊椎动物","鱼类");
  121.         myTree.add("哺乳动物","猫");
  122.         myTree.add("哺乳动物","牛");
  123.         myTree.add("哺乳动物","人");
  124.         System.out.println("-----------获取父结点-----------");
  125.         String parent= myTree.getParent("鱼类");
  126.         System.out.println(parent);
  127.         System.out.println("-----------获取子结点-----------");
  128.         List<String> child=myTree.getChild("动物");
  129.         for (int i=0;i<child.size();i++){
  130.             System.out.println(child.get(i));
  131.         }
  132.         System.out.println("-----------获取兄弟结点-----------");
  133.         List<String> brother=myTree.getBrother("脊椎动物");
  134.         for (int i=0;i<brother.size();i++){
  135.             System.out.println(child.get(i));
  136.         }
  137.         System.out.println("-----------获取祖先结点-----------");
  138.         List<String> foreFathers=myTree.getForefathers("人");
  139.         for (int i=0;i<foreFathers.size();i++){
  140.             System.out.println(foreFathers.get(i));
  141.         }
  142.         System.out.println("-----------h获取子孙结点-----------");
  143.         List<String> grandChildren=myTree.getGrandChildren("root");
  144.         for (int i=0;i<grandChildren.size();i++){
  145.             System.out.println(grandChildren.get(i));
  146.         }
  147.     }
  148. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/201976
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号