内存中字的存储：
 
低位字节放在低地址单元，高位字节放在高地址单元：
 
例如：2000D(4E20H),存放在0，1两个单元
18D（0012H），存放在2，3两个单元
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wQiYEuvJ-1604221227498)(C:\Users\46591\Desktop\汇编语言学习\汇编中内存字的存储.assets\image-20201101165515245.png)]
 
字单元：由两个地址连续内存单元组成存放一个字型数据（16位）
 
原理：在一个字单元中低地址单元存放低位字节，高地址单元存放高位字节

 
我们都知道虚拟机的内存划分了多个区域，并不是一张大饼。那么为什么要划分为多块区域呢，直接搞一块区域，所有用到内存的地方都往这块区域里扔不就行了，岂不痛快。是的，如果不进行区域划分，扔的时候确实痛快，可用的时候再去找怎么办呢，这就引入了第一个问题，分类管理，类似于衣柜，系统磁盘等等，为了方便查找，我们会进行分区分类。另外如果不进行分区，内存用尽了怎么办呢？这里就引入了内存划分的第二个原因，就是为了方便内存的回收。如果不分，回收内存需要全部内存扫描，那就慢死了，内存根据不同的使用功能分成不同的区域，那么内存回收也就可以根据每个区域的特定进行回收，比如像栈内存中的栈帧，随着方法的执行栈帧进栈，方法执行完毕就出栈了，而对于像堆内存的回收就需要使用经典的回收算法来进行回收了，所以看起来分类这么麻烦，其实是大有好处的。
 
提到虚拟机的内存结构，可能首先想起来的就是堆栈。对象分配到堆上，栈上用来分配对象的引用以及一些基本数据类型相关的值。但是·虚拟机的内存结构远比此要复杂的多。除了我们所认识的(还没有认识完全)的堆栈以外，还有程序计数器，本地方法栈和方法区。我们平时所说的栈内存，一般是指的栈内存中的局部变量表。
 
从图中可以看到有5大内存区域，按照是否被线程所共享可分为两部分，一部分是线程独占区域，包括Java栈，本地方法栈和程序计数器。还有一部分是被线程所共享的，包括方法区和堆。什么是线程共享和线程独占呢，非常好理解，我们知道每一个Java进行都会有多个线程同时运行，那么线程共享区的这片区域就是被所有线程一起使用的，不管有多少个线程，这片空间始终就这一个。而线程的独占区，是每个线程都有这么一份内存空间，每个线程的这片空间都是独有的，有多少个线程就有多少个这么个空间。上图的区域的大小并不代表实际内存区域的大小，实际运行过程中，内存区域的大小也是可以动态调整的。下面来具体说说每一个区域的主要功能。
 
程序计数器，我们在写代码的过程中，开发工具一般都会给我们标注行号方便查看和阅读代码。那么在程序在运行过程中也有一个类似的行号方便虚拟机的执行，就是程序计数器，在c语言中，我们知道会有一个goto语句，其实就是跳转到了指定的行，这个行号就是程序计数器。存储的就是程序下一条所执行的指令。这部分区域是线程所独享的区域，我们知道线程是一个顺序执行流，每个线程都有自己的执行顺序，如果所有线程共用一个程序计数器，那么程序执行肯定就会出乱子。为了保证每个线程的执行顺序，所以程序计数器是被单个线程所独显的。程序计数器这块内存区域是唯一一个在jvm规范中没有规定内存溢出的。
 
java虚拟机栈，java虚拟机栈是程序运行的动态区域，每个方法的执行都伴随着栈帧的入栈和出栈。 栈帧也叫过程活动记录，是编译器用来实现过程/函数调用的一种数据结构。栈帧中包括了局部变量表，操作数栈，方法返回地址以及额外的一些附加信息，在编译过程中，局部变量表的大小已经确定，操作数栈深度也已经确定，因此栈帧在运行的过程中需要分配多大的内存是固定的，不受运行时影响。对于没有逃逸的对象也会在栈上分配内存，对象的大小其实在运行时也是确定的，因此即使出现了栈上内存分配，也不会导致栈帧改变大小。
 
一个线程中，可能调用链会很长，很多方法都同时处于执行状态。对于执行引擎来讲，活动线程中，只有栈顶的栈帧是最有效的，称为当前栈帧，这个栈帧所关联的方法称为当前方法。执行引擎所运行的字节码指令仅对当前栈帧进行操作。Ft5rk58GfiJxcdcCzGeAt8fjkFPkMRdf
 
局部变量表：我们平时所说的栈内存一般就是指栈内存中的局部变量表。这里主要是存储变量所用。对于基本数据类型直接存储其值，对于引用数据类型则存储其地址。局部变量表的最小存储单位是Slot，每个Slot都能存放一个boolean、byte、char、short、int、float、reference或returnAddress类型的数据。
 
既然前面提到了数据类型，在此顺便说一下，一个Slot可以存放一个32位以内的数据类型，Java中占用32位以内的数据类型有boolean、byte、char、short、int、float、reference和returnAddress八种类型。前面六种不需要多解释，大家都认识，而后面的reference是对象的引用。虚拟机规范既没有说明它的长度，也没有明确指出这个引用应有怎样的结构，但是一般来说，虚拟机实现至少都应当能从此引用中直接或间接地查找到对象在Java堆中的起始地址索引和方法区中的对象类型数据。而returnAddress是为字节码指令jsr、jsr_w和ret服务的，它指向了一条字节码指令的地址。
 
对于64位的数据类型，虚拟机会以高位在前的方式为其分配两个连续的Slot空间。Java语言中明确规定的64位的数据类型只有long和double两种(reference类型则可能是32位也可能是64位)。值得一提的是，这里把long和double数据类型读写分割为两次32读写的做法类似。不过，由于局部变量表建立在线程的堆栈上，是线程私有的数据，无论读写两个连续的Slot是否是原子操作，都不会引起数据安全问题。
 
操作数栈是一个后入先出(Last In First Out, LIFO)栈。同局部变量表一样，操作数栈的最大深度也在编译的时候被写入到字节码文件中，关于字节码文件，后面我会具体的来描述。操作数栈的每一个元素可以是任意的Java数据类型，包括long和double。32位数据类型所占的栈容量为1，64位数据类型所占的栈容量为2。在方法执行的任何时候，操作数栈的深度都不会超过在max_stacks数据项中设定的最大值。
 
当一个方法刚刚开始执行的时候，这个方法的操作数栈是空的，在方法的执行过程中，会有各种字节码指令向操作数栈中写入和提取内容，也就是入栈出栈操作。例如，在做算术运算的时候是通过操作数栈来进行的，又或者在调用其他方法的时候是通过操作数栈来进行参数传递的。
 
举个例子，整数加法的字节码指令iadd在运行的时候要求操作数栈中最接近栈顶的两个元素已经存入了两个int型的数值，当执行这个指令时，会将这两个int值和并相加，然后将相加的结果入栈。
 
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，在编译程序代码的时候，编译器要严格保证这一点，在类校验阶段的数据流分析中还要再次验证这一点。再以上面的iadd指令为例，这个指令用于整型数加法，它在执行时，最接近栈顶的两个元素的数据类型必须为int型，不能出现一个long和一个float使用iadd命令相加的情况。
 
本地方法栈 与虚拟机栈所发挥的作用是非常相似的，其区别不过是虚拟机栈为虚拟机执行Java方法(也就是字节码)服务，而本地方法栈则是为虚拟机使用到的Native方法服务。虚拟机规范中对本地方法栈中的方法使用的语言、使用方式与数据结构并没有强制规定，因此具体的虚拟机可以自由实现它。甚至有的虚拟机(譬如Sun HotSpot虚拟机)直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一样，本地方法栈区域也会抛出StackOverflowError和OutOfMemoryError异常。
 
方法区经常会被人称之为永久代，但这俩并不是一个概念。首先永久代的概念仅仅在HotSpot虚拟机中存在，不幸的是，在jdk8中，Hotspot去掉了永久代这一说法，使用了Native Memory，也就是Metaspace空间。那么方法区是干嘛的呢？我们可以这么理解，我们要运行Java代码，首先需要编译，然后才能运行。在运行的过程中，我们知道首先需要加载字节码文件。也就是说要把字节码文件加载到内存中。好了，问题就来了，字节码文件放到内存中的什么地方呢，就是方法区中。当然除了编译后的字节码之外，方法区中还会存放常量，静态变量以及及时编译器编译后的代码等数据。
 
堆，一般来讲堆内存是Java虚拟机中最大的一块内存区域，同方法区一样，是被所有线程所共享的区域。此区域所存在的唯一目的就存放对象的实例(对象实例并不一定全部在堆中创建)。堆内存是垃圾收集器主要光顾的区域，一般来讲根据使用的垃圾收集器的不同，堆中还会划分为一些区域，比如新生代和老年代。新生代还可以再划分为Eden，Survivor等区域。另外为了性能和安全性的角度，在堆中还会为线程划分单独的区域，称之为线程分配缓冲区。更细致的划分是为了让垃圾收集器能够更高效的工作，提高垃圾收集的效率。
 
如果想要了解更多的关于虚拟机的内容，可以观看录制的这套视频教程。

java中字节流和字符流的区别如何
 
 
 
 
 
[java] view plain copy
 
 
 
package com.cn;  
  
import java.io.BufferedReader;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.FileReader;  
import java.io.FileWriter;  
import java.io.InputStreamReader;  
import java.io.PrintWriter;  
  
  
import org.junit.Test;  
  
public class Tests {  
  
    /** 
     * @param args 
     */   
    @Test  
    public void Iotest() throws Exception{  
         String str="中国";  
         //方式一 使用字节流输入，字节流输出，使用了字节流缓冲区  
         FileOutputStream  fos=new FileOutputStream("D://1.txt");  
         fos.write(str.getBytes("UTF-8"));  
         fos.close();  
           
         FileInputStream  fr=new FileInputStream("D://1.txt");  
         byte[] buf=new byte[1024];  
         int len;  
         String myStr="";  
         while((len=fr.read(buf))!=-1){  
             myStr+=new String(buf, 0, len, "UTF-8");  
         }  
         System.out.println("使用字节流输出的字符为      "+myStr);  
           
           
         //方式二  使用字符流输入，字符流输出，使用了字符缓冲区  
            String str2="中国你好";  
           FileWriter  fw=new FileWriter("D://2.txt");  
           fw.write(str2);  
           fw.close();  
             
           FileReader fr2=new FileReader("D://2.txt");  
           char [] buf2= new char[1024];  
           int len2=fr2.read(buf2);  
           //在这里必须要加上编码字符集，否则会出现乱码  
           String myStr2=new String(buf2, 0, len2);  
           System.out.println("使用字符流输出的字符是    "+myStr2);  
             
          // 方式三 使用字符流输入，字符流输出，没有使用缓冲区 ，直接读行  
            String str3="中国更好";  
           PrintWriter  pw=new PrintWriter("D://3.txt");  
           pw.write(str3);  
           pw.close();  
             
           BufferedReader br=new BufferedReader(new InputStreamReader(new  FileInputStream("D://3.txt")));  
           String myStr3=br.readLine();  
           br.close();  
           System.out.println("没有缓冲区      "+myStr3);  
    }  
}  

 输出结果；
 
 
 
 
 
 
字节流与和字符流的使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同呢？

 实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如图。
 
 
 
字节流与字符流
 
在java.io包中操作文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream，在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成。（这四个都是抽象类）
 
 
 
java中提供了专用于输入输出功能的包Java.io,其中包括：
      InputStream,OutputStream,Reader,Writer
      InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,
      Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串.
 

字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点
      所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列
 
      字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 2. 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以
        字节流是最基本的，所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的 但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的 

https://www.ithome.com/html/soft/11633.htm（ediary增加格式刷等功能）
 #java中的输入输出流
 输入流（InputStream）
 
输出流(OutputStream)
 
https://www.cnblogs.com/liuhuijie/p/10359259.html
 
字节流：
 InputStream和OutputStream是字节流的两个顶层父类，提供了输入流类和输出流类的通用API。
 1、输入字节流
 InputStream基本方法：
 (1)基本读方法;: int read() int read（byte[] b） int read(byte[] b,int off,int len)
 (2) 关闭流：void close()
 (3) 返回输入流中还有多少可读字节 int available()
 (4) 跳过指定字节 long skip(long n)
 (5) 回读数据 boolean markSupported() void Mark(int readlimt) void reset()
 2 、输出字符流
 OutputStream基本方法：
 （1）基本写方法：void write（int c） void write(byte[] b) void write(byte[] b,int off,int len)
 (2) 关闭流：void close()
 (3)q强制输出：void flush（）
 
字符流
 Reader和Writer是字符流的顶层父类，字符流能够处理Unicode字符集中的所有字符。成员方法和字节流类似。
 
文件流：文件流属于节点流，包括FileInputStream和FileOutputStream类以及Reader和Writer类。这些类都是对文件系统中的文件进行读写。文件流的创建是调用相应的构造方法，并经常以字符串形式的文件名或者一个File类的对象为参数，例如：
 1 public FileInputStream(String name);
 
2 public FileInputStream(File file);
 
https://blog.csdn.net/u010276761/article/details/52692962
 package javastream;
 
import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 
public class FileInputOutPutStream {
 
public static void main(String[] args) throws IOException {
 
 FileInputStream inputSteam = new FileInputStream(new File("D:\\data/file1.txt"));
 FileOutputStream outPutSteam =new  FileOutputStream(new File("D:\\data/file2.txt"));
 int a;
 while((a=inputSteam.read())!=-1){ //读到的有数据，输出到文件2
	 
	 outPutSteam.write(a);
	 System.out.println(a);//inputSteam.read()这个方法每次从数据源中读取一个byte并返回；而read()方法在读的时候是每次读取8个二进制位，这8个0或1就是我们所谓的一个byte（字节）
	 //在计算机中，所有的文件都是以二进制的形式存储的，换句话说，每个文件不管是什么类型，在计算机中的形式都是一串0和1
	//实际上在Java中，byte就是一个0-255之间的整数，而将从文件中读取的二进制转化成十进制这一过程是由read()方法完成的
	 
 }
 
 inputSteam.close();
 outPutSteam.close();
 
}
 }