精华内容
下载资源
问答
  • 什么是数组? --》数组就是存储相同数据类型的一组数据 区---》new 新建的对象 区--》基本数据类型,内存地址 转载于:https://www.cnblogs.com/zhaozhaozhang/p/5754397.html...

    什么是数组?

    --》数组就是存储相同数据类型的一组数据

     

    堆区---》new 新建的对象

    栈区--》基本数据类型,内存地址

    转载于:https://www.cnblogs.com/zhaozhaozhang/p/5754397.html

    展开全文
  • 利用java数组实现

    2019-01-21 14:57:36
    作为被广泛使用的数据结构,是一个特定范围的存储单元中存储的数据,这些数据可以重新被取出使用,与线性表相比,它们的插入和删除受到更多的约束和限定,所以又称为限定性的线性表结构。不同的是,是一个FIFO...

    栈作为被广泛使用的数据结构,是在一个特定范围的存储单元中存储的数据,这些数据可以重新被取出使用,与线性表相比,它们的插入和删除受到更多的约束和限定,所以又称为限定性的线性表结构。不同的是,栈是一个FILO结构,
    下面是采用java数组的方式时实现栈

    /**
     * 利用java数组实现栈
     *
     * @author VicterTian
     * @version V1.0
     * @Date 2019/1/21
     */
    public class MyStackByArray<E> {
    	/**
    	 * 定义一个栈
    	 */
    	private Object[] stack;
    	/**
    	 * 定义数组中存储元素的个数
    	 */
    	private int size;
    
    	private MyStackByArray() {
    		// 栈的初始长度为10
    		stack = new Object[10];
    	}
    
    	/**
    	 * 判断堆栈是否为空
    	 */
    	private Boolean isEmpty() {
    		return this.size == 0;
    	}
    	/**
    	 * 返回栈顶元素,却不删除
    	 */
    	@SuppressWarnings("unchecked")
    	private E peek(){
    		if (isEmpty()){
    			return null;
    		}
    		return (E) stack[size-1];
    	}
    
    	/**
    	 * 弹栈
    	 */
    	private E pop(){
    		E e = peek();
    		stack[size -1] = null;
    		size--;
    		return e;
    	}
    
    	/**
    	 * 压栈
    	 * @param item 要压栈的数据
    	 */
    	private void push(E item){
    		ensureCapacity(size+1);
    		stack[size ++] = item;
    	}
    	/**
    	 * 判断数组容器是否已满,若已满则扩充空间
    	 */
    	private void ensureCapacity(int size){
    		int length = stack.length;
    		if(size > length){
    			int newLen = 10;
    			// copyOf()是系统自动在内部新建一个数组,
    			// 调用arraycopy()将original内容复制到copy中去,并且长度为newLength。
    			// 返回copy; 即将原数组拷贝到一个长度为newLength的新数组中,并返回该数组
    			stack = Arrays.copyOf(stack,newLen);
    		}
    	}
    	/**
    	 * 测试
    	 */
    	public static void main(String[] args) {
    		MyStackByArray<Integer> myStack = new MyStackByArray<>();
    		myStack.push(1);
    		myStack.push(2);
    		System.out.println("myStack.size = " + myStack.size);
    		System.out.println("myStack.pop() = " + myStack.pop());
    		System.out.println("myStack.pop() = " + myStack.pop());
    	}
    }
    
    
    展开全文
  • 这一篇主要还是Java基础, 基础语句语法、 数组、内存分配及的区别。 1. Java基本语句结构 1.1 语句结构种类 顺序结构 选择结构 循环结构 1.2 顺序结构 从上到下依次执行 1.3 选择结构【可以嵌套...

    Java基础-基本语句语法-方法-数组-内存分配及栈和堆的区别

    最近一段比较忙,抽出时间,来更一篇。 这一篇主要还是Java基础, 基础语句语法、 数组、内存分配及栈和堆的区别。

    1. Java基本语句结构

    • 1.1 语句结构种类

      • 顺序结构
      • 选择结构
      • 循环结构
    • 1.2 顺序结构

      • 从上到下依次执行
    • 1.3 选择结构【可以嵌套】

      • if , if else , if else if …… else
      • switch case【支持byte,short,char,int,String】
    • 1.4 循环结构

    • for

      for(初始化语句;判断条件语句;控制条件语句) {
               循环体语句;
      }
      第一步:先执行初始化语句,只执行一次
      第二步:执行判断条件语句
      第三部:执行循环体语句
      第四步:执行控制条件语句,然后再执行循环体语句【循环】
      
    • while

      初始化语句;
      while(判断条件语句) {
          循环体语句;
          控制条件语句;
      }
      
    • do while

      do {
              循环体语句;
      }while((判断条件语句);
      

    2.Java方法

    2.1 定义

    • 方法就是完成特定功能的代码块
      • 1:系统方法,只需要会使用,不需要知道内部的结构
      • 2:自定义方法:方法的内部实现需要我们来写
      • 3:方法内部不能再嵌套方法

    2.2 格式

    • 方法格式

      修饰符   返回值类型   方法名(参数类型 参数 , ……){
           函数体
           return 返回值
      }
      
    • 修饰符: public static或直接是public或是其它 private

    • 返回类型:所有的数据类型(基本类型:int ,char ,float, long, 引用类型:String)

    • 方法名:1:见名知意 2: getMax

    • 参数类型:所有的数据类型 ,如果一个方法没有返回值,则返回值类型为void

    • 参数名:变量名

    • 返回值:就是要返回的结果(这个结果必须和返回类型一致)

    3. 变量的使用范围

    3.1. 方法范围

    看一段代码:

    publiic class xxx{
    
    public static void main(String args){
        
        int num1 = 10;
        
        int num2 = 15;
        
        for(int i = 0; i< 10; i ++){
            
            System.out.println("i: "+ i);
            System.out.println("num1+num2"+(num1+num2));
        }
        
       /// 这句话 是编译不过的 说明了 int 类型 变量名 为i的 这个变量的使用范围只有在for 循环内, 超出范围 , 便引用不到了。
       /// System.out.println("i: "+ i);
        
        System.out.println("num1-num2:"+ (num1-num2));
        
    }
    }
    
    

    看上边的这个例子,为什么 num1, 和num2 的使用范围 为什么可以在for 循环内呢,
    因为 for 循环也属于方法的一部分, 而 num1 num2 是属于方法范围的访问范围, 也就是说 在整个方法内都可访问。

    3.2. 类范围

    再看一段代码:

    public class test{
        private int p ;
        private String str;
        private boolean b;
        
        public static void main(String args[]){
            
            System.out.println("p: "+ p  + " str: "+str + " b: "+b);
            p = 10;
            str = "sssss";
            b = true;
            
            System.out.println("after : p: "+ p  + " str: "+str + " b: "+b);
        }
        
    }
    
    

    类范围的变量, 如果不初始化则为变量的默认值, int 为0 , string 为 null , boolean 为 false
    修改的结果为 10 , ssss, true
    使用的访问范围 就是 类内。

    3.3. 方法块

    再来看一个

    public class xxx{
        
        private static  Map<String,String> params = new HashMap<String,String>();
        static {
            
            params.put("a","A");
            params.put("b","B");
            params.put("c","C");
            params.put("d","D");
            
        }
        
        public static void main(String args[]){
            
            for(Map.Entry<String,String> entry: params.entrySet()){
                
                System.out.println("key: "+entry.getKey() + " value: "+ entry.getValue());
            }
        }
        
    }
    

    静态方法块是在类实例初始化之前 , 也就是类加载的时候初始化的, 这样就可以保证在调用之前 有了赋值。

    3.4. 常量与静态变量

    我们知道C/C++ 中的常量修饰符 是const ,
    Java 中的常量修饰符是final
    静态变量 、静态方法、 静态类 关键字是static
    看个代码:

    public class xxx{
    
     public final String name = "rose";
     /  这里的声明顺序 可以final 或者static 在前边 
     public final static name2 = "jack";
     
     public static void main(String args[]){
        
        System.out.print("rose + jack "+ (rose +"&"+ jack)); 
         
     }   
        
    }
    

    3.5. 静态方法和非静态方法

    • 静态方法属于类所有,类实例化前即可使用;

    • 非静态方法可以访问类中的任何成员,静态方法只能访问类中的静态成员;

    • 因为静态方法在类实例化前就可以使用,而类中的非静态变量必须在实例化之后才能分配内存;

    在使用上面,静态方法中只能调用静态成员或者方法,不能调用非静态方法或者非静态成员,而非静态方法既可以调用静态成员或者方法又可以调用其他的非静态成员或者方法。
    再来个例子

    class xxx {
    	public int sum(int a,int b){//非静态方法
    	  return a+b;
    	}
    	public static void main(String[] args){
    		int  result=sum(1,2);//静态方法调用非静态方法
    	    System.out.println("result="+result);
    	}
    }
    
    

    这样编译就会出错, 怎么办,
    静态方法可以调用静态方法, 把sum 改成静态方法

    class xxx{
    	public static int sum(int a,int b){//加入static关键字,变成静态方法
    	  return a+b;
    	}
    	public static void main(String[] args){
    		int  result=sum(1,2);//静态方法调用静态方法
    	    System.out.println("result="+result);
    	}
    }
    

    要么, 这样, 实例化类对象, 调用

    class xxx{
    	public int sum(int a,int b){
    	  return a+b;
    	}
    	public static void main(String[] args){
    		Test test=new Test();//实例化类
    		int  result=test.sum(1,2);//调用非静态方法
    	    System.out.println("result="+result);
    	}
    }
    
    

    4.Java访问控制符

    上边说了Java方法的基本格式与声明方法, 这里说一下Java中的访问修饰符, 不多, 就两步,一起来看一下。

    4.1.访问控制符有哪些

    • Java有四种访问控制级别:public、protected、private和friendly(即不加修饰符,默认访问级别为包访问级别 )

    4.2.类访问控制符

    • 类访问控制修饰符包括:public或默认访问级别
      • 使用public访问控制修饰符使得类变为公有的,没有使用访问控制修饰符的类则具有默认的访问级别
      • 公有类在任何地方都是可见的
      • 默认访问级别的类只能由属于同一个包中的类使用

    4.3.类成员访问控制符

    • 类成员(方法、字段、构造方法等)可以具备四种访问控制级别之一
      • public使得类成员成为公有的
      • protected使得类成员成为受保护的
      • private使得类成员成为私有的
      • 没有使用访问控制修饰符的话,类成员将会拥有默认的访问级别
    • 具体如下所示
      访问级别 从其他包中的类来访问 从同一包中的其他类来访问 从同一个类
      public 可以 可以 可以
      private 不可以 不可以 可以
      protected 若是子类,直接调用则可以。若非子类,也不可以 可以 可以
      default 不可以 可以 可以
    • 注意:
      • protected修饰的话,若是子类,直接调用则可以,声明对象后再调用则不可以

    5.数组

    5.1 数组概念

    • 数组是一个容器,可以存储多个变量,这些变量数据类型要一致
    • 数组既可以存储基本数据类型,也可以存储引用数据类型

    5.2 一维数组

    数组定义格式
    * 格式1:数据类型【】 数组名
    * 格式2:数据类型 数组名【】
    int[] a; 定义了一个int类型的数组a; int a[]; 定义了一个int类型的a数组; 推荐使用第一种定义方式。

    数组的初始化
    * Java中的数组必须先初始化,然后才能使用。
    * 所谓初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值。

    初始化分类:
    * a:动态初始化: 只指定长度,由系统给出初始化值
    * b:静态初始化: 给出初始化值,由系统决定长度
    * 注意事项:这两种方式,只能使用一种,不能进行动静结合

    5.3 二维数组

    数组定义格式

    • 数据类型[][] 变量名 = new 数据类型[m][n];

    • m表示这个二维数组有多少个一维数组

    • n表示每一个一维数组的元素个数

      举例:

        int[][] arr = new int[3][2];
        定义了一个二维数组arr
        这个二维数组有3个一维数组,名称是arr[0],arr[1],arr[2]
        每个一维数组有2个元素,可以通过arr[m][n]来获取,表示获取第m+1个一维数组的第n+1个元素
    

    6.Java的内存分配以及栈和堆的区别

    6.1 先了解几个概念

    • 方法区
    • 本地方法去
    • 寄存器
    A:栈: 存放的是局部变量
    局部变量:在方法定义或者方法声明上的变量都是局部变量。
    B:堆: 存放的是所有new出来的东西
    特点:
        a: 每一个new出来的东西都会为其分配一个地制值。
        b: 每一个变量都有一个默认的值
            byte,short,int,long  -- 0
            float,double            -- 0.0
            char                    -- '\u0000'
            boolean                -- false
            引用数据类型               -- null       
        c: 使用完毕就变成了垃圾,等待垃圾回收器对其回收
    C:方法区:(面向对象部分讲解)
    D:本地方法区:(和系统相关)
    E:寄存器:(cpu使用)
    

    7.总结

    主要就是一些Java中的基本基础知识, 如果想学好Java 就上手敲吧 , 多试试,多看看 就会了, 我们下篇见

    展开全文
  • 数组内存分析 内存简述 内存是计算机中的重要原件,临时数据存储区域,作用是运行程序。我们编写的程序是存放硬盘中,硬盘中的程序是不会运行的,必须放在内存中才能运行,运行完毕后会i清空内存。 Java虚拟机要...

    数组内存分析

    内存简述

    内存是计算机中的重要原件,临时数据存储区域,作用是运行程序。我们编写的程序是存放在硬盘中,在硬盘中的程序是不会运行的,必须放在内存中才能运行,运行完毕后会i清空内存。

    Java虚拟机要运行程序,必须要对内存进行空间的分配和管理

    Java虚拟机的内存划分

    为提高效率就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据的方式和内存管理方式。

    JVM 的内存划分:

    区域名称 作用
    寄存器 给CPU使用,和我们开发无关
    本地方法栈 JVM在使用操作系统功能的时候使用,和我们开发无关
    方法区 存储可以运行的class文件
    堆内存 存储对象或者数组,new创建的都存储在堆内存中
    方法栈 方法运行时使用的内存,比如main方法运行,进入方法栈中执行

    数组在内存中的存储

    public static void main(String[]args){
        //定义一个长度为3的数组
        int[] arr = new int[3];
        //直接打印这个数组
        System.out.println(arr);//[I@880ec60
    }
    
    • 输出的结果为[I@880ec60,这个是数组在内存中的地址
    • new出来的内容都是在堆内存中存储的
    • 而方法中的变量arr保存的是数组的地址,存储在栈内存中

    在这里插入图片描述

    两个变量指向一个数组

    public static void main(String[]args){
        int[] arr = new int[3];
        arr[0]=10;
        arr[1]=20;
        arr[2]=30;
        //将数组赋值给另一个变量
        int[]arr2 = arr;
        //为数组第二个元素重新赋值
        arr2[1] = 200;
        System.out.println(arr[1]);//200
    }
    
    • 将一个数组变量赋值给第二个变量,其实是将数组本身在堆内存中的地址给了第二个变量
    • 因为第二个变量获得了数组的地址,所以进行修改元素的值时,堆内存中的数组元素的值就发生了改变
    • 再次使用第一个变量就会发现里面的元素已经发生了改变。所以进行修改元素的值时,堆内存中的数组元素的值就发生了改变
    • 再次使用第一个变量就会发现里面的元素已经发生了改变。
    展开全文
  • 数组1.数组的定义同一种类型数据的集合,存放数据的容器,就叫做数组。抽象一个数组模型:创建数组的定义方式:元素类型 [ ] 数组名称 = new 元素类型 [元素的个数或数组的长度] 示例:int [ ] array = new int [5];...
  • JAVA 数组

    2021-01-27 19:07:58
    数组 储存在堆内存中 :主要用于运行函数的内存 堆:主要用于存储数据对象的内存 对于数组 数组本质上就是在堆内存中一系列地址连续且空间大小相等的存储空间(变量),每一个存 储空间...
  • 数组存储在栈还是堆

    万次阅读 2015-08-31 09:53:45
    今天看代码,定义了一个结构体 typedef struct {  int a;  int b;  int char[6*1024];... 我的第一反应是,怎么可以定义这么大数据,容易把搞死(理由:数组保存在栈空间)。 哎...忘了是
  • 引述:当我们需要定义多个同一的数据类型来进行以后的运算的时候(例如,我们要需求是统计某公司的员工的工资),这是我们会定义很多的变量,但是这样极大的不便,所以java提供了数组给我们。 概述:数组储存同一...
  • JAVA数组的内存(

    千次阅读 2017-02-01 19:51:45
    JAVA对内存空间的划分五部分: 方法区 本地方法区 寄存器今天主要谈和堆栈内存:存储的都是局部变量。 只要是方法中定义的变量都是局部变量,一旦变量的生命周期结束,该变量就被释放。 (压栈弹 ...
  • java数组内存、内存。什么是内存,什么是内存一、一维数组中的内存、内存。1、一维数组1.1数组概念:1.2数组初始化2、一维数组之内存3、一维数组值内存 前言 说到内存、内存。为什么要提及...
  • Java 数组存储机制

    2019-04-14 16:01:24
    数组用来存储类型相同的一组数据,一旦初始化完成,其所占的空间也确定下来了,即使清除某个元素,其所占用的空间仍然存在,即,数组的长度不能被改变,且数组只有分配空间后才能使用。 数组的初始化方式有两种,a...
  • 这里写目录标题要求:1定义属性1.1定义Object类型一维数组1.2栈帧,永远指向部元素2压栈2.1(1)和(2)本质上一样,注意分清楚是先自加1,赋值2.2注意:所有的System.out.println()方法执行时,如果输出饮用的...
  • Stack 1、Stack概述   这个数据结构有着自己的性质,也就是 先进后出,后进先出 的结构。...  这里将设计为Java接口,目的是实现的底层有很多。例如数组、链表、二叉树等等。他们都将调用这个...
  • Java数组

    千次阅读 2016-07-21 18:49:56
    java数组 java二位数组
  • java数组存储方式

    千次阅读 2016-10-29 21:28:33
    本文有Arckal撰写,转载请注明出处:http://blog.csdn.net/u014108439/article/details/52966794Java数组是一种引用数据类型。数组变量并不是数组本身,而是指向内存中存放的数组对象。什么是内存和内存呢,先...
  • java数组存储方式

    千次阅读 2020-07-25 09:48:09
    java数组在内存中的存储方式 数组的引用存在中,而数组中的元素都存储在堆中。数组作为一种容器,它在堆中所被分配的是一段连续的空间。用来存放元素,这段连续的空间每一个空间都有下标,下标是连续的对应的! ...
  • 文章目录java 代码运行结果 java 代码 package org.feng.datastruct; import java.util.Arrays; /** * java 使用数组简单实现 * @param <... // 底层用数组存储数据 private Object[] stac...
  • 那么,在java中如何利用数组来实现这两种数据结构的呢?一、实现:就是用一个数组来实现这个数据结构/** * 因为所有的数据结构必然是要落地的,所以在Java中如何去吧和队列这两个数据结构表现出来呢 * 我们...
  • Java数组存储在内存中的什么地方

    千次阅读 2017-04-19 22:22:16
    new int[]{element1,element2,element3} 为数组对象,存储在堆中。 当数组对象失去引用时,垃圾回收器才会清除这个对象。或者将数组引用复制为 null时,垃圾回收器也会清除这个对象。Java数组中没有
  • 需要一个空间存储数值,这里用数组存储数据; 一个size变量 指示当前的大小; 一个top指针 始终指向栈顶,以便完成出栈入栈操作; 因为数组 有空间大小 所以需要一个MAX_SIZE来规定当前数组最大容量,防止发生...
  • JAVA数组

    2020-08-03 12:02:52
    Java数组 数组的概念: (1)数组是用来存放数据的, (2)数组用来将相同数据类型存储在存储单元里,数组的所有元素必须属于相同的数据类型。可以保存多条数据; (3)数组是引用数据类型。 为什么使用数组: ...
  • java数组

    2016-10-21 08:59:24
    二、new在堆内存中开辟存储空间。将此地址赋给变量名的栈存储空间。 数组定义 1、声明数组 数据类型[ ] 数组名; 例如:int[ ] a; 此外java保留c的格式。元素类型 数组名[ ] 2、开辟元素空间 1)数组名=new 元素类型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 121,953
精华内容 48,781
关键字:

java数组存储在堆还是栈

java 订阅