精华内容
下载资源
问答
  • Java实验-数组的定义、初始化方法 掌握数组的遍历方法 掌握Arryas的使用
  • 二叉树的初始化: package BinaryTree; public class BinaryTree { int data;//父结点 BinaryTree leftTree;//左子结点 BinaryTree rightTree;//右子结点 public BinaryTree(int data) { this.data = data...

    二叉树的初始化:

    package BinaryTree;
    
    
    public class BinaryTree {
        int data;//父结点
        BinaryTree leftTree;//左子结点
        BinaryTree rightTree;//右子结点
    
        public BinaryTree(int data) {
            this.data = data;
            leftTree = null;
            rightTree = null;
        }
    
        /**
         *二叉树的右子结点比父结点大  左子结点比父结点小
         */
        public void insert(BinaryTree root, int data) {
            if (data > root.data) {
                if (root.rightTree == null) {
                    root.rightTree = new BinaryTree(data);
                } else {
                    this.insert(root.rightTree, data);
                }
            } else {
                if (root.leftTree == null) {
                    root.leftTree = new BinaryTree(data);
                } else {
                    this.insert(root.leftTree, data);
                }
            }
        }
    }
    

    二叉树遍历:

    package BinaryTree;
    
    import java.util.Queue;
    import java.util.concurrent.LinkedBlockingQueue;
    
    
    public class Order {
        /**
         * 前序遍历
         * @param root
         */
        public static void preorder(BinaryTree root){
            if(root != null){
                System.out.print(root.data + " ");
                preorder(root.leftTree);
                preorder(root.rightTree);
            }
        }
    
        /**
         * 中序遍历
         * @param root
         */
        public static void inorder(BinaryTree root){
            if(root != null){
                inorder(root.leftTree);
                System.out.print(root.data + " ");
                inorder(root.rightTree);
            }
        }
    
    
        /**
         * 后序遍历
         * @param root
         */
        public static void postorder(BinaryTree root){
            if(root != null){
                postorder(root.leftTree);
                postorder(root.rightTree);
                System.out.print(root.data + " ");
            }
        }
    
    
        /**
         * 层序遍历  利用队列先进先出来进行层层遍历
         * @param root
         */
        public static void sequenceorder(BinaryTree root){
            if(root != null){
                Queue<BinaryTree> queue = new LinkedBlockingQueue<>();
                BinaryTree binaryTree;
                queue.add(root);//将已初始化二叉树根结点放入队列之中
                while (!queue.isEmpty()){
                    binaryTree = queue.remove();
                    System.out.print(binaryTree.data + " ");//每次将上次进入队列的结点输出
                    if(binaryTree.leftTree != null){
                        queue.add(binaryTree.leftTree);
                    }
                    if(binaryTree.rightTree != null){
                        queue.add(binaryTree.rightTree);
                    }
                }
            }
        }
    }
    

    测试:

    package BinaryTree;
    
    
    public class MyTest {
        public static void main(String[] args) {
            int []arr = {13, 1, 2, 25, 39, 59, 79, 22, 34, 28, 37};
            BinaryTree binaryTree = new BinaryTree(arr[0]);//初始化根结点
            for (int i = 1; i < arr.length; i++) {
                binaryTree.insert(binaryTree, arr[i]);//初始化二叉树
            }
            System.out.println("先序遍历");
            Order.preorder(binaryTree);
            System.out.println();
            System.out.println("中序遍历");
            Order.inorder(binaryTree);
            System.out.println();
            System.out.println("后序遍历");
            Order.postorder(binaryTree);
            System.out.println();
            System.out.println("层序遍历");
            Order.sequenceorder(binaryTree);
        }
    }

    输出结果:

    先序遍历
    13 1 2 25 22 39 34 28 37 59 79 
    中序遍历
    1 2 13 22 25 28 34 37 39 59 79 
    后序遍历
    2 1 22 28 37 34 79 59 39 25 13 
    层序遍历
    13 1 25 2 22 39 34 59 28 37 79 
    Process finished with exit code 0

    二叉树的定义、性质及遍历方法:https://blog.csdn.net/a572463931/article/details/106094769

    展开全文
  • Java 数组 初始化方式总结: 第一种:静态初始化 所谓静态初始化初始化时由程序员显式指定每个数组元素的初始值,有系统决定数组的长度; 简单实例: String[] strArr = {"张三","李四","王五"}; 第二种:动态...

    Java 数组 初始化方式总结:

    第一种:静态初始化

    所谓静态初始化:初始化时由程序员显式指定每个数组元素的初始值,有系统决定数组的长度;

    简单实例:

    String[] strArr = {"张三","李四","王五"};

    第二种:动态初始化

    所谓动态初始化:初始化时由程序员指定数组的长度,由系统初始化每个数组元素的默认值。

    String[] strs = status.split(",");
    Integer[] multipleStatus = new Integer[strs.length];
    for(int i = 0; i < strs.length; i++){
    		multipleStatus[i] = Integer.valueOf(strs[i]);
    }

    Java 数组 遍历方式总结:

    前提:初始化数组数据

    String[] strArr = {"张三","李四","王五"};

    第一种:根据下标遍历

    for(int i = 0; i < strArr.length; i++){
        // 自定义业务逻辑
    }

    第二种:foreach遍历

    for(String x : strArr){
        // 自定义业务逻辑
    }

    第三种:迭代器遍历

    List list = Arrays.asList(strArr);
    Iterator it1 = list.iterator();
    while(it1.hasNext()){
        String str = it1.next();
        // 自定义业务逻辑
    }

    第四种:stream 遍历

    Arrays.asList(strArr).stream().forEach(x -> System.out.println(x));

    另外一种写法:

    Arrays.asList(strArr).stream().forEach(System.out::println);

     

    展开全文
  • java中数组的声明、初始化遍历和数组中元素的默认值。
    java新手,这些基础知识一直记不住,所以就写出来加深记忆。
    一、数组的声明:
    Java数组有两种声明方式
    //数组的两种声明方式
    		int[] a;
    		int b[];
    二、数组的初始化
    Java数组有三种初始化方式:
      1. 静态初始化

        //静态初始化
        		int[] array1 = {4,5,6};

      2. 用new声明,之后分别初始化数组中的每个元素,声明时需指定数组大小。

        //用new声明,之后分别初始化数组中的每个元素
        		int[] array2 = new int[3];
        		array2[0] = 1;
        		array2[1] = 2;
        		array2[2] = 3;

      3. 用new声明的同时初始化,这种方式不能指定数组的大小,数组大小由初始化列表中数据个数决定。

        //用new声明的同时初始化
        		int[] array3 = new int[]{1,2,3};
        

    三、数组的遍历
               

    Java数组有两种遍历方式:

      1. for遍历

        //for循环遍历
        		System.out.print("for循环遍历数组:");
        		for(int i = 0; i < 3; i++){
        			System.out.print("  " + array1[i]);
        		}
        

          2、foreach遍历
    //foreach遍历数组
    		System.out.print("foreach循环遍历数组:");
    		for(int i: array2){
    			System.out.print("  " + i);
    		}
    四、基本数据类型对应数组中元素的默认值
    int数组中元素默认值是:0
    double数组中元素默认值是:0.0
    float数组中元素默认值是:0.0
    char数组中元素默认值是:‘\0'
    boolean数组中元素默认值是:false
    int[] iArray = new int[3];
    		double[] dArray = new double[3];
    		float[] fArray = new float[3];
    		char[] cArray = new char[3];
    		boolean[] bArray = new boolean[3];
    		
    		System.out.println("int数组中元素默认值是:" + iArray[0]);
    		System.out.println("double数组中元素默认值是:" + dArray[0]);
    		System.out.println("float数组中元素默认值是:" + fArray[0]);
    		System.out.println("char数组中元素默认值是:" + cArray[0]);
    		System.out.println("boolean数组中元素默认值是:" + bArray[0]);
    		System.out.println((cArray[0] == ' ' ? true: false));
    		System.out.println(cArray[0] == '\0' ? true: false);

    输出如下:
            int数组中元素默认值是:0
           double数组中元素默认值是:0.0
           float数组中元素默认值是:0.0
           char数组中元素默认值是:
           boolean数组中元素默认值是:false
           false
           true


    欢迎各位大神批评指正。
    源代码如下:
    package array;
    
    public class ArrayTest {
    	public static void main(String[] args){
    		int[] iArray = new int[3];
    		double[] dArray = new double[3];
    		float[] fArray = new float[3];
    		char[] cArray = new char[3];
    		boolean[] bArray = new boolean[3];
    		
    		System.out.println("int数组中元素默认值是:" + iArray[0]);
    		System.out.println("double数组中元素默认值是:" + dArray[0]);
    		System.out.println("float数组中元素默认值是:" + fArray[0]);
    		System.out.println("char数组中元素默认值是:" + cArray[0]);
    		System.out.println("boolean数组中元素默认值是:" + bArray[0]);
    		System.out.println((cArray[0] == ' ' ? true: false));
    		System.out.println(cArray[0] == '\0' ? true: false);
    		
    		//数组的两种声明方式
    		int[] a;
    		int b[];
    		
    		//静态初始化
    		int[] array1 = {4,5,6};
    		
    		//用new声明,之后分别初始化数组中的每个元素
    		int[] array2 = new int[3];
    		array2[0] = 1;
    		array2[1] = 2;
    		array2[2] = 3;
    		
    		//用new声明的同时初始化
    		int[] array3 = new int[]{1,2,3};
    		
    		//for循环遍历
    		System.out.print("for循环遍历数组:");
    		for(int i = 0; i < 3; i++){
    			System.out.print("  " + array1[i]);
    		}
    		System.out.println();
    		
    		//foreach遍历数组
    		System.out.print("foreach循环遍历数组:");
    		for(int i: array2){
    			System.out.print("  " + i);
    		}
    		System.out.println();
    	}
    }
    






    展开全文
  • Java遍历Map效率对比

    千次阅读 2019-03-25 21:04:11
    Java遍历Map效率对比 Java 中Map容器的遍历有多种方式,但是不同的方式效率会大有不同,以前没有注意这些细节,随意使用遍历方式在本地可能没有什么影响,但是在项目在高频使用需要特别注意,尽量使用高效的方式。 ...

    Java遍历Map效率对比

    Java 中Map容器的遍历有多种方式,但是不同的方式效率会大有不同,以前没有注意这些细节,随意使用遍历方式在本地可能没有什么影响,但是在项目在高频使用需要特别注意,尽量使用高效的方式。

    首先,Map.Entry<K,V>是可以包含了Key和Value的,keySet包含了所有的Key,再使用get方法可以拿到对应的Value;所以包含Key和Value内容的就有两种方式,我们再看访问模式,可以使用迭代器Iterator 访问,也可以使用For循环访问;那么2种包含方式和访问模式组合起来就是4种访问方式

    初始化Map

    导入相应的包

    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    

    我们选择不同规模Key记录来测试不同方式的差异

        Map<String, String> map = new HashMap<>();
        String key, value;
        int num = 10000; // num值从{1w, 10w, 100w, 1000w}中选择
        for (int i = 1; i <= num; i++) {
          key = "mykey" + i;
          value = "myvalue" + i;
          map.put(key, value);
        }
    

    keySet 与 Iterator

        long startTime1 =System.currentTimeMillis();
        Iterator<String> iter = map.keySet().iterator();
        while (iter.hasNext()){
          key=iter.next();
          value=map.get(key);
        }
        long endTime1 =System.currentTimeMillis();
        System.out.println("Run:"+(endTime1-startTime1)+"ms KeySet && Iterator");
    

    keySet 与 for-loop

        long startTime2 =System.currentTimeMillis();
        for(String key2:map.keySet()){
          value=map.get(key2);
        }
        long endTime2 =System.currentTimeMillis();
        System.out.println("Run:"+(endTime2-startTime2)+"ms KeySet && For-Loop");
    

    Map.Entry<K,V> 与 Iterator

        long startTime3=System.currentTimeMillis();
        Iterator<Map.Entry<String,String>> iter3 =map.entrySet().iterator();
        Map.Entry<String,String> entry3;
        while (iter3.hasNext()){
          entry3 = iter3.next();
          key = entry3.getKey();
          value=entry3.getValue();
        }
        long endTime3 =System.currentTimeMillis();
        System.out.println("Run:" +(endTime3-startTime3)+"ms Map.Entry && Iterator");
    

    Map.Entry<K,V> 与 for-loop

        long startTime4=System.currentTimeMillis();
        for(Map.Entry<String,String> entry4:map.entrySet()){
          key=entry4.getKey();
          value=entry4.getValue();
        }
        long endTime4 =System.currentTimeMillis();
        System.out.println("Run:"+(endTime4-startTime4) +"ms Map.Entry && For-Loop");
    

    效率比较

    以下运行时间单位为毫秒(ms)

    Key数量 Entry && Iterator Entry && For-Loop KeySet && Iterator KeySet && For-Loop
    10000(1w) 2 1 3 2
    100000(10w) 8 6 10 8
    1000000(100w) 38 32 39 36
    10000000(1000w) 236 251 316 319

    对比结论

    多次验证,上述结果变化基本不大。使用Map.Entry<K,V>与for循环的组合是最有效率的

    Map常用方法

    Set<K> keySet()
    Collection<V> values()
    V get(Object key)
    boolean containsKey(Object key)
    boolean containsValue(Object value)
    V getOrDefault(Object key, V defaultValue)
    

    Java8 Map的遍历使用了新的方式forEach,这个函数就非常方便了,但是forEach中的值k,v是不可变的,在Java中是final的,这样就无法将k,v赋值给外部的变量了。如果一定要修改外部的值,需要用一个初值来累加/减/乘/除等操作

        Map<String, String> map = new HashMap<>();
        String key, value;
        int num = 10;
        for (int i = 1; i <= num; i++) {
          key = "mykey" + i;
          value = "myvalue" + i;
          map.put(key, value);
        }
    
        map.forEach((k, v) -> {  // 非常方便
          System.out.println(k + ":" + v);
        });
    

    把一个Map全部放到另外一个Map中

    void putAll(Map<? extends K,? extends V> m)
    

    删除一个键值对

    boolean remove(Object key)
    

    替换一个键值对

    boolean	replace(K key, V oldValue, V newValue)
    

    替换Map中所有Entry的value值,这个值由旧的key和value计算得出

    void replaceAll(BiFunction<? super K,? super V,? extends V> function)
    

    参考

    1. Map-Javadoc
    2. Map遍历效率比较
    3. 遍历HashMap的几种方式及其效率比较,HashMap删除元素时如何处理
    4. Java中HashMap的四种遍历方法,及效率比较
    展开全文
  • java遍历set

    2017-07-07 14:56:20
    set遍历主要通过for和iterator来遍历所有的值。 private Set set = new HashSet(); public static void main(String[] args) { // |初始化 testSet testSet = new testSet();... System.out.println("初始化
  • (1)Java数组定义格式 1.数据类型[] 数组名=new 数据类型[数组长度]; 例如:int[] array=new int [3];//即为定义一个长度为3且数组名为array的整数型数组。 1.数据类型数组名[]=new 数据类型[数组长度]; 例如...
  • 主要介绍了Java编程中HashMap的初始化以及遍历的方法,是Java入门学习中的基础知识,需要的朋友可以参考下
  • java遍历数组返回位置

    2019-08-17 00:23:52
    import java.util.Scanner; import javax.xml.soap.SAAJResult; /** * @author 大杨 *@date 2019年8月13日 下午3:10:52 */ public class LinearArray { public static void main(String[] args) { Scanner input=...
  • Java 多叉树的实现,完成树的初始化遍历。包括两个文件(TreeNode.java和TreeHelper.java) TreeNode完成树节点的数据结构,TreeHelper通过输入一个TreeNode列表,生成一颗有一个树根的树!其它函数接口自己看...
  • 本文从其他地方摘抄了一个多叉树设计,包括两个文件(TreeNode.java和TreeHelper.java) TreeNode完成树节点的数据结构,TreeHelper通过输入一个TreeNode列表,生成一颗有一个树根的树!希望能有帮助。 ...
  • import java.util.Scanner;//定义二叉树结点类型 class CBTType { String data;//元素数据 CBTType left; CBTType right; } class Main { static final int MAXLEN = 20; static Scanner input = new Scanner
  • Java Map是Java中的一个集合,常用的比较熟悉的集合还有List 但Map不同于List的是,...那么下面就介绍Java Map的初始化,常用用法等 Map.Entry则是Map的一个内部接口 Map提供常用方法 如可以Set(),entrySet()等 ...
  • java 遍历arrayList的四种方法 package com.test; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class ArrayListDemo {  public static void main(Str
  • 二维数组动态初始化 动态初始化格式: 数据类型[][] 变量名 = new 数据类型[m][n]; m表示这个二维数组,可以存放多少个一维数组 n表示每一个一维数组,可以存放多少个元素 示例代码: package com.itheima.demo; ...
  • 二维数组的初始化遍历

    千次阅读 2019-04-16 15:38:54
    二维数组的初始化遍历等 通过二维数组计算若干个班级若干个学生的平均分。 public class Main { public static void main(String[] args) { // 使用二维数组计算若个个个班学生的平均分 // 先输入有多少个班,在...
  • //初始化list和map的数据 for(int i=0;i;i++){ list.add(new String("list"+i) ); map.put(i, new String("map"+i)); } Iterator iterList= list.iterator();//List接口实现了Iterable接口 //...
  • 结点Node信息如下: public class Node { public int data; public Node left; //左右子结点 public Node right; public Node(int data){ this.data = data; this.left = null; this.right = null; ...
  • java窗体初始化下拉框

    千次阅读 2018-09-12 13:48:12
    2.像jsp页面一样页面加载执行函数初始化,动态赋值。 /** * 初始化部门下拉框 */ private void initDept() { //移除下拉框所有选项 jComboBox1.removeAllItems(); //首先添加一个item ...
  • 一、初步认识数组1.理解数组Java提供了数组这种数据结构,主要可以将大量的数据存储...数组是定长的,一旦一个数组被初始化,那么这个数组的长度就不能再发生改变 d.数组相当于是一个容器 e.数组中存储的数据被称为元素
  • Java 数组遍历

    2017-04-16 20:37:53
    一维数组遍历和二维数组遍历类似,只不过在遍历到一维元素时,由于元素是一维数组还需要遍历,构成双重...方式一:静态初始化,每一维在定义时就确定 public class Demo3 {   public static void ma
  • 数组介绍(静态,动态初始化)数组的遍历 数组介绍(静态,动态初始化) 数组的遍历 数组遍历案例 数组中常见的异常 数组我们常说的是一维数组,二维数组等等,严格意义来说在java中是没有一维数组的,数据本身...
  • java安全编码指南之:声明和初始化

    万次阅读 2020-09-06 08:56:11
    根据JLS(Java Language Specification)中的定义,class在初始化过程中,需要同时初始化class中定义的静态初始化程序和在该中声明的静态字段(变量)的初始化程序。 而对于static变量来说,如果static变量被...
  • java类初始化

    千次阅读 2016-05-24 22:35:44
    简单的归纳一下java类初始化: 基础知识: 对于一个,我们可以看到他有 public 类名{} 这样子形式的的构造方法,java中,我们把这样子的方法叫做默认构造器或者无参构造器 可以注意到的是,这个方法没有返回值,...
  • java中常见集合遍历

    千次阅读 2016-10-20 15:23:17
    我们经常在工作当中使用到集合,java当中的集合较多,且自带有丰富方法可对集合中的元素进行灵活操作,我们在使用时不必考虑数据结构和算法实现细节,只需创建集合对象直接使用即可,这给我们带来了极大的便利。...
  • public class Test {  public static void main(String[] args)  {  List<String> tt = new ArrayList(Arrays.asList("you", "can", "call", "me", "sk,"));...比较倾向于第一种初始化方法和第一种遍历~
  • 最近总结了下,二叉树的遍历的非递归实现过程,以下是整个java实现过程 package com.test.dayumianshi; import java.util.*; public class BinaryTreeRank { //存储除根结点所有节点的集合 private static ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 214,112
精华内容 85,644
关键字:

java遍历初始化类

java 订阅