JAVA空控制台学习笔记

转x33g5p2x  于2021-11-22 转载在 Java  
字(10.7k)|赞(0)|评价(0)|浏览(361)

ArrayList于LinkList（链表）

  • 首先讲解一下LinkList，我们之前讲过动态数组ArrayList，ArrayList基于动态数组实现的非线程安全的集合；LinkedList基于链表实现的非线程安全的集合。
  • 对于随机index访问的get和set方法，一般ArrayList的速度要优于LinkedList。因为ArrayList直接通过数组下标直接找到元素；LinkedList要移动指针遍历每个元素直到找到为止。
  • 新增和删除元素，一般LinkedList的速度要优于ArrayList。因为ArrayList在新增和删除元素时，可能扩容和复制数组；LinkedList实例化对象需要时间外，只需要修改指针即可。
  • LinkedList集合不支持 高效的随机随机访问（RandomAccess）
  • ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

我们要使用java实现一个多级菜单，显而易见需要用到树形结构，那么怎样去写一个树形结构呢？

首先：我们创建一个TreeNode类：然后写一个Node的内部类：

  1. public  static  class  Node<T>{
  2.         private T data = null;
  3.         private List<Node<T>> children = new ArrayList<>();
  4.         private  Node<T> parent = null;
  5.         }

接下来我们需要为他构建方法和设置get set方法：

  1. public Node(T data) {
  2.             this.data = data;
  3.         }
  5.         public T getData() {
  6.             return data;
  7.         }
  9.         public void setData(T data) {
  10.             this.data = data;
  11.         }
  13.         public List<Node<T>> getChildren() {
  14.             return children;
  15.         }
  17.         public void setChildren(List<Node<T>> children) {
  18.             this.children = children;
  19.         }
  21.         public Node<T> getParent() {
  22.             return parent;
  23.         }
  25.         public void setParent(Node<T> parent) {
  26.             this.parent = parent;
  27.         }
  28.         /** * 定义增加单个子节点的方法 */
  29.         public  Node<T> addChild(Node<T> child){
  30.             child.setParent(this);  //this代表children对象本身
  31.             this.children.add(child);
  32.             return  child;
  33.         }
  34.         /** *添加多个子节点 */
  35.         public void addChildren(List<Node<T>> children) {
  36.             children.forEach(each -> each.setParent(this));
  37.             this.children.addAll(children);
  38.         }

这里插入一下lambda表达式的讲解：

说白了就是 ->这个符号 前面写参数后面写方法：

  1. // 1. 不需要参数,返回值为 5 
  2. () -> 5  
  3.   
  4. // 2. 接收一个参数(数字类型),返回其2倍的值 
  5. x -> 2 * x  
  6.   
  7. // 3. 接受2个参数(数字),并返回他们的差值 
  8. (x, y) -> x – y  
  9.   
  10. // 4. 接收2个int型整数,返回他们的和 
  11. (int x, int y) -> x + y  
  12.   
  13. // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void) 
  14. (String s) -> System.out.print(s)

然后我们需要往这个树里面添加节点，那么怎样添加呢？举个粒子：

  1. Node<String> node1_china = new Node<String>("1.中国");

首先新建一个顶节点：node1_china，然后为这个顶节点添加一个子节点：

  1. Node<String> node1_1 = node1_china.addChild(new Node<String>("1.北京"));

这里的北京就是一个子节点使用了上面的addChild方法

  1. Node<String> node1_1 = node1_china.addChild(new Node<String>("1.北京"));

不断的按照梯形去添加新的节点：

  1. Node<String> node1_china = new Node<String>("1.中国");
  3.             Node<String> node1_1 = node1_china.addChild(new Node<String>("1.北京"));
  4.             
  5.             Node<String> node1_1_1 = node1_1.addChild(new Node<String>("1.朝阳区")) ;
  6.             Node<String> node1_1_2 = node1_1.addChild(new Node<String>("2.海定区"));
  7.             Node<String> node1_1_3 = node1_1.addChild(new Node<String>("3.昌平区"));
  9.             Node<String> node1_2 = node1_china.addChild(new Node<String>("2.湖北"));
  10.             
  11.             Node<String> node1_2_1 = node1_2.addChild(new Node<String>("1.武汉市")) ;
  12.             Node<String> node1_2_2 = node1_2.addChild(new Node<String>("2.襄樊市"));
  13.             Node<String> node1_2_3 = node1_2.addChild(new Node<String>("3.咸宁市"));
  15.             
  16.             Node<String> node1_3 = node1_china.addChild(new Node<String>("3.湖南"));
  17.             
  18.             Node<String> node1_3_1 = node1_3.addChild(new Node<String>("1.长沙市")) ;
  19.             Node<String> node1_3_2 = node1_3.addChild(new Node<String>("2.株洲市"));
  20.             Node<String> node1_3_3 = node1_3.addChild(new Node<String>("3.湘潭市"));
  24.             Node<String> node2_USA = new Node<String>("2.美国");
  26.             Node<String> node2_1 = node2_USA.addChild(new Node<String>("1.纽约市") ) ;
  27.             
  28.             Node<String> node2_1_1 = node2_1.addChild(new Node<String>("1.曼哈顿"));
  29.             Node<String> node2_1_2 = node2_1.addChild(new Node<String>("2.布鲁克林"));
  30.             Node<String> node2_1_3 = node2_1.addChild(new Node<String>("3.皇后区"));
  32.             Node<String> node2_2 = node2_USA.addChild(new Node<String>("2.德克萨斯") ) ;
  33.             
  34.             Node<String> node2_2_1 = node2_2.addChild(new Node<String>("1.奥斯汀"));
  35.             Node<String> node2_2_2 = node2_2.addChild(new Node<String>("2.休斯顿"));
  36.             Node<String> node2_2_3 = node2_2.addChild(new Node<String>("3.达拉斯"));
  38.             Node<String> node2_3 = node2_USA.addChild(new Node<String>("3.加利福尼亚") ) ;
  39.             
  40.             Node<String> node2_3_1 = node2_3.addChild(new Node<String>("1.洛杉矶"));
  41.             Node<String> node2_3_2 = node2_3.addChild(new Node<String>("2.旧金山"));
  42.             Node<String> node2_3_3 = node2_3.addChild(new Node<String>("3.奥克兰"));

然后我们再定义一个顶尖节点，将两个定点放入：

  1. Node<String> rootNode = new Node<String>("");
  2.             rootNode.addChild(node1_china);
  3.             rootNode.addChild(node2_USA);

接下来就需要要写打印输出的方法了：

为了可以有阶梯感，我们再构造打印方法的时候需要传入两个参数，一个就是要打印的树另一个是一个空格：

  1. public  static  void printTree(Node<String> node, String appender){
  2.             System.out.println(appender+node.getData());
  3.             node.getChildren().forEach(each -> printTree(each,appender+appender));
  4.         }

全部代码：

  1. package 任务三;
  3. import 任务三.树形菜单.NewTest;
  5. import java.util.ArrayList;
  6. import java.util.List;
  8. /** * @author ${范涛之} * @Description * @create 2021-11-16 15:21 */
  9. public class TreeNode {
  10.     public  static  class  Node<T>{
  11.         private T data = null;
  12.         private List<Node<T>> children = new ArrayList<>();
  13.         private  Node<T> parent = null;
  15.         public Node(T data) {
  16.             this.data = data;
  17.         }
  19.         public T getData() {
  20.             return data;
  21.         }
  23.         public void setData(T data) {
  24.             this.data = data;
  25.         }
  27.         public List<Node<T>> getChildren() {
  28.             return children;
  29.         }
  31.         public void setChildren(List<Node<T>> children) {
  32.             this.children = children;
  33.         }
  35.         public Node<T> getParent() {
  36.             return parent;
  37.         }
  39.         public void setParent(Node<T> parent) {
  40.             this.parent = parent;
  41.         }
  42.         /** * 定义增加单个子节点的方法 */
  43.         public  Node<T> addChild(Node<T> child){
  44.             child.setParent(this);  //this代表children对象本身
  45.             this.children.add(child);
  46.             return  child;
  47.         }
  48.         public void addChildren(List<Node<T>> children) {
  49.             children.forEach(each -> each.setParent(this));
  50.             this.children.addAll(children);
  51.         }
  53.         public static void main(String[] args) {
  54.             Node<String> node1_china = new Node<String>("1.中国");
  56.             Node<String> node1_1 = node1_china.addChild(new Node<String>("1.北京"));
  58.             Node<String> node1_1_1 = node1_1.addChild(new Node<String>("1.朝阳区")) ;
  59.             Node<String> node1_1_2 = node1_1.addChild(new Node<String>("2.海定区"));
  60.             Node<String> node1_1_3 = node1_1.addChild(new Node<String>("3.昌平区"));
  62.             Node<String> node1_2 = node1_china.addChild(new Node<String>("2.湖北"));
  64.             Node<String> node1_2_1 = node1_2.addChild(new Node<String>("1.武汉市")) ;
  65.             Node<String> node1_2_2 = node1_2.addChild(new Node<String>("2.襄樊市"));
  66.             Node<String> node1_2_3 = node1_2.addChild(new Node<String>("3.咸宁市"));
  68.             Node<String> node1_3 = node1_china.addChild(new Node<String>("3.湖南"));
  70.             Node<String> node1_3_1 = node1_3.addChild(new Node<String>("1.长沙市")) ;
  71.             Node<String> node1_3_2 = node1_3.addChild(new Node<String>("2.株洲市"));
  72.             Node<String> node1_3_3 = node1_3.addChild(new Node<String>("3.湘潭市"));
  76.             Node<String> node2_USA = new Node<String>("2.美国");
  78.             Node<String> node2_1 = node2_USA.addChild(new Node<String>("1.纽约市") ) ;
  80.             Node<String> node2_1_1 = node2_1.addChild(new Node<String>("1.曼哈顿"));
  81.             Node<String> node2_1_2 = node2_1.addChild(new Node<String>("2.布鲁克林"));
  82.             Node<String> node2_1_3 = node2_1.addChild(new Node<String>("3.皇后区"));
  84.             Node<String> node2_2 = node2_USA.addChild(new Node<String>("2.德克萨斯") ) ;
  86.             Node<String> node2_2_1 = node2_2.addChild(new Node<String>("1.奥斯汀"));
  87.             Node<String> node2_2_2 = node2_2.addChild(new Node<String>("2.休斯顿"));
  88.             Node<String> node2_2_3 = node2_2.addChild(new Node<String>("3.达拉斯"));
  90.             Node<String> node2_3 = node2_USA.addChild(new Node<String>("3.加利福尼亚") ) ;
  92.             Node<String> node2_3_1 = node2_3.addChild(new Node<String>("1.洛杉矶"));
  93.             Node<String> node2_3_2 = node2_3.addChild(new Node<String>("2.旧金山"));
  94.             Node<String> node2_3_3 = node2_3.addChild(new Node<String>("3.奥克兰"));
  96.             Node<String> rootNode = new Node<String>("");
  97.             rootNode.addChild(node1_china);
  98.             rootNode.addChild(node2_USA);
  100.             printTree(rootNode," ");
  102.         }
  104.         public  static  void printTree(Node<String> node, String appender){
  105.             System.out.println(appender+node.getData());
  106.             node.getChildren().forEach(each -> printTree(each,appender+appender));
  107.         }
  108.     }
  109. }

心得：

这道题自己确实还是很不熟悉，感觉到了最后在用到遍历的时候还有Lambda表达式很生疏，现在自己理解一下：这是一个先输出再遍历的方法， System.out.println(appender+node.getData());这里输出了我们的数据data也就是我们最一开始定义的第一个子节点：node1_china，然后开始递归调用，通过foreach循环这个子节点的“子子”节点，“子子”节点的打印输出和最开始的node1_china使用同样的方式， node.getChildren().forEach(each -> printTree(each,appender+appender));也就是这行代码的后面那部分，我们创建了一个each临时变量来代替子节点、“子子”节点以及后面的“子子子节点”，通过->这个Lambda表达式，也就是“参数”->“方法”，实现遍历，这里的方法就是外面的printTree方法。

打印输出的版本：

  1. package 任务三;
  3. import java.util.Scanner;
  5. /** * @author ${范涛之} * @Description * @create 2021-11-16 21:51 */
  6. public class TestNode2 {
  7.     public static void main(String[] args) {
  8.         /** * 定义所有节点 */
  9.         String s1 = "1.中国";
  10.         String s1_1 = "1.北京";
  11.         String s1_2 = "2.湖北";
  12.         String s1_3 = "3.湖南";
  13.         String s1_1_1 = "1.朝阳区";
  14.         String s1_1_2 = "2.海淀区";
  15.         String s1_1_3 = "3.昌平区";
  16.         String s1_2_1 = "1.武汉市";
  17.         String s1_2_2 = "2.襄樊市";
  18.         String s1_2_3 = "3.咸宁市";
  19.         String s1_3_1 = "1.长沙市";
  20.         String s1_3_2 = "2.株洲市";
  21.         String s1_3_3 = "3.湘潭市";
  22.         String s2 = "2.美国";
  23.         String s2_1 = "1.纽约州";
  24.         String s2_2 = "2.德克萨斯";
  25.         String s2_3 = "3.加利福尼亚";
  26.         String s2_1_1 = "1.曼哈顿";
  27.         String s2_1_2 = "2.布鲁克林";
  28.         String s2_1_3 = "3.皇后区";
  29.         String s2_2_1 = "1.奥斯汀";
  30.         String s2_2_2 = "2.休斯顿";
  31.         String s2_2_3 = "3.达拉斯";
  32.         String s2_3_1 = "1.洛杉矶";
  33.         String s2_3_2 = "2.旧金山";
  34.         String s2_3_3 = "3.奥克兰";
  36.         /** * 使用多维数组存放 */
  38.         String[] country = {s1, s2};
  39.         String[][] province = {{s1_1, s1_2, s1_3}, {s2_1, s2_2, s2_3}};
  40.         String[][][] position = {
  41.                 {
  42.                         {s1_1_1, s1_1_2, s1_1_3},
  43.                         {s1_2_1, s1_2_2, s1_2_3},
  44.                         {s1_3_1, s1_3_2, s1_3_3},
  45.                 },
  46.                 {
  47.                         {s2_1_1, s2_1_2, s2_1_3},
  48.                         {s2_2_1, s2_2_2, s2_2_3},
  49.                         {s2_3_1, s2_3_2, s2_3_3},
  50.                 }
  51.         };
  53.         System.out.println("请输入国家编号： 1：中国--2：美国");
  55.         Scanner scanner = new Scanner(System.in);
  56.         int t1 = scanner.nextInt();
  57.         while (true){
  58.             if (t1!=1 && t1!=2){
  59.                 System.out.println("请输入1或者2");
  60.                 continue;
  61.             }
  62.             else {
  63.                 if (t1 == 1){
  64.                     System.out.println(country[0]);
  65.                     System.out.println("中国的省份有：1：北京 2：湖北 3：湖南");
  66.                 }else {
  67.                     System.out.println(country[1]);
  68.                     System.out.println("美国的省份有：1：纽约 2：德克萨斯 3：加利福尼亚");
  69.                 }
  71.                 break;
  72.             }
  73.         }
  75.         System.out.println("请输入省份编号1-3");
  77.         int t2 = scanner.nextInt();
  78.         while (true){
  79.             if (t2!=1 && t2!=2 && t2!=3){
  80.                 System.out.println("请输入1-3之间的数字");
  81.                 continue;
  82.             }
  83.             else {
  84.                 System.out.println(province[t1-1][t2-1]+"省的地区有:");
  85.                 for (String s: position[t1-1][t2-1]) {
  86.                     System.out.println(s);
  87.                 }
  88.                 break;
  89.             }
  90.         }
  91.         System.out.println("请输入地区编号1-3");
  93.         int t3 = scanner.nextInt();
  94.         while (true){
  95.             if (t3!=1 && t3!=2 && t3!= 3){
  96.                 System.out.println("请输入1-3之间的数");
  97.             }
  98.             else {
  99.                 System.out.println(position[t1-1][t2-1][t3-1]);
  100.             }
  101.             break;
  102.         }
  104.     }
  106. }

参考了另一位同学的代码并作出了改进：完善了输出：

分割线

管道命令理解：就是前面命令的输出结果作为后面命令的输入结果：

明日再看…

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/justleavel/article/details/121352963

内容来源于网络，如有侵权，请联系作者删除！

mysqlMaven数据库java学习

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com