数据类型
首先介绍一下数据有哪些类型

1.char 字符型

2.short 短整形

3.int 整形

4.long 长整形

5.long long 更长的整形

6.float 单精度浮点型

7.double 双精度浮点型

注：不同的数据类型有不同的数据范围以及不同的存储方式
整形家族包括char、short、int、long以及long long，它们有分为无符号型（unsigned）以及有符号型。
浮点家族有float和double。
整形的存储方式
首先我们要了解原码、反码以及补码的概念。

1.原码：将数据直接转换为二进制位就是原码

ps：二进制的最高位是符号位，1为负，0为正。

2.反码：符号位不变，其它位按位取反就得到了反码。

3.补码：反码+1。

ps：正数的原反补相同。
整形是以补码存储在内存中。

why？

在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理； 同

时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需

要额外的硬件电路。
其次要介绍大小端

1.大端存储：数据的低位放在内存的高位，数据的高位放在地址的低位。

2.小端存储：数据的低位放在内存的低位，数据的高位放在地址的高位。

如何确定你的机器是大端还是小端呢？

将1放在int类型的变量i中，若是大端，i的内存中存放的便是0x00 00 00 01，而小端则是0x01 00 00 00。

char类型的指针解引用时只解引用一个字节，将i强制转换为char类型再进行解引用，如果是1，为小端，0为大端。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//判断大小端
//int check_sys()
//{
//	int i = 1;
//	return *((char*)&i);//char*解引用只访问一个字节
//}
//int main()
//{
//	int n = check_sys();
//	if (n)
//	{
//		printf("小端存储。\n");
//	}
//	else
//	{
//		printf("大端存储。\n");
//	}
//	return 0;
//}


接下来看看一些有趣的代码
int main()
{
	char a = -1;
	signed char b = -1;
	unsigned char c = -1;
	printf("a=%d,b=%d,c=%d", a, b, c);
	return 0;
}


c打印出来的居然是255，是不是很神奇啊。

这里是因为将-1的补码也就是11111111放在unsigned char类型中，所以电脑认为它是一个以11111111为二进制的正数，十进制为255。
int main()
{
	char a[1000];
	int i;
	for (i = 0; i<1000; i++)
	{
		a[i] = -1 - i;
	}
	printf("%d", strlen(a));
	return 0;
}


这个答案又是什么呢？



那么为什么是255呢？

首先简单介绍一下strlen这个函数：

strlen计算的是字符串的长度，遇到‘\0’停止。

所以我们要计算i==0之前的元素个数。

//11111111 -1

//11111110 -2

//11111101 -3

//…

//10000000 -128  这里默认为-128

//01111111 127

//…

//00000001 1

总共255个

//00000000 0

如果你清楚的知道char类型的范围，这个代码对你来说就是小菜一碟了。
所以说我们学习一个数据类型时，不但要知道它再内存中的存储方式，还要知道它的范围。

浮点型数据的存储方式
首先我们来看看一段代码，你试着将这端代码的结果写出来。
int main()
{
	int n = 9;
	//00000000000000000000000000001001
	float *pFloat = (float *)&n;
	printf("n的值为:%d\n", n);//9
	printf("*pF1oat的值为︰%f\n", *pFloat);//0
	*pFloat = 9.0;
	printf("num的值为:%d\n", n);//很大
	printf("*pF1oat的值为:%f\n", *pFloat); return 0;//9.000000
}



没想到会是这个结果吧，那到底是为什么呢？
要了解这段代码，首先我们要知道浮点数在内存的存储方式。
任何二进制浮点数都可以写成（-1）^符号位 * 有效数字位 * 2^ 指数位。
float类型有32bit，有1bit为符号位，8bit为有效指数位，23bit为有效数字位，如图

1.符号位，0为正，1为负。

2.指数位，其为无符号整形，但我们知道当出现小数时，指数应该是负数，所以官方规定指数存入内存时会加一个中间值（127/1023）再转换为二进制，取出时与上述过程相反，但需注意以下两点：

1.全为1，即为2^（255-127）是一个巨大的数（±无穷大）

2.全为0，即2^(1-127)无限接近0。
所以之前的代码中：

9的补码为00000000000000000000000000001001

以int型打印就是9，而以float型打印就是0

而9.0存储在内存中的形式为：

9.0 -> 1001.0 ->(-1)01.00123 -> s=0, M=1.001,E=3+127=130

0 10000010 001 0000 0000 0000 0000 0000

以整形打印就是以0 10000010 001 0000 0000 0000 0000 0000为二进制位转换而成的十进制位数字。
double的存储方式相同，只不过double的指数位有11bit，有效数字位有52bit。

数据在内存中的储存(一）
一、整型在内存中的储存
我们之前讲过一个变量的创建是要在内存中开辟内存空间的。空间的大小是根据不同的类型而决定的。
我们知道int a=0;为a分配四个字节的空间，那如何储存？

对于整型来说：数据存放内存中实际存放的是补码。

原码：直接将二进制按照正负数的形式翻译成二进制就可以；

反码：将原码的符号位不变，其他位依次按位取反就可以得到；

补码：反码+1就得到。

正数的原、反、补码都相同。
eg：内存中的储存：

Int a=-10;      内存中：（小端模式) 0X f6 ff ff ff

f f->1111 1111  f f->1111 1111  f f->1111 1111  f 6->1111 0110

11111111111111111111111111110110-补码

11111111111111111111111111110101-补码-1得到反码

10000000000000000000000000001010-符号位不变，其他位取反 得到原码

根据原码得 -10
二、大小端
大端存储模式：数据的低位保存在内存的高地址中。

小端存储模式：数据的低位保存在内存的低地址中。

下面展示一些 内联代码片。
设计一个小程序来判断当前机器的字节序：
#include<stdio.h>

int check()
{
	int i = 1;
	char *p = (char*)&i;

	return *p;
}
int main()
{
	int ret = check();
	if (ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}


三、整形提升
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器的操作的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器长度。

因此，即使是两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU是难以直接实现两个8比特字节直接相加运算的。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int 或 unsigned int ，然后才能送入CPU去执行运算。
Eg :char a,b,c;

a=b+c;

b和c的值被提升为普通整型，然后再执行加法运算。加法运算完成后，结果将被截断，然后再存储于a中。（要根据char的符号类型来提升，比如：unsigned char：高位补零；signed char：按符号位提升）
练习

下面展示一些 内联代码片。
#include<stdio.h>

int main()
{
	char a = -1;
	signed char b = -1;
	unsigned char c = -1;
	printf("a=%d,b=%d,c=%d", a, b, c);
	return 0;
}


内存中int a的补码是：

11111111111111111111111111111111

char a的补码是（截断后）：

11111111

打印整形printf(“a=%d”,a),因为char a是signed char a所以按符号位进行提升，提升后：

11111111111111111111111111111111
unsigned char c=-1;

截断后：11111111

打印整形printf(“c=%d”,c),因为unsigned char a是无符号类型，所以提升时做无符号提升：采用高位补0的方式，提升后：

00000000000000000000000011111111

因为正数的原码、反码、补码相同，所以int c=255

点击进入_更多_Java千百问



1、存放基本类型数组在内存中如何储存

java的数组中可以存放引用类型。 

存放引用类型的内存分布相比存放基本类型相对复杂。来看一段存储基本类型的程序: 

了解什么是数组看这里：java中的数组是什么 

了解数组在内存中的储存看这里：java数组如何存储在内存中



public class TestPrimitiveArray {
    public static void main(String[] args) {
        //1.定义数组
        int[] numbers;
        //2.分配内存空间
        numbers = new int[4];
        //3.为数组元素指定值
        for(int i = 1;i <= numbers.length;i++) {
            numbers[i] = i ;
        }
    }
}

内存分布如图：



从图中可看出数组元素直接存放在堆内存中，当操作数组元素时，实际上是操作基本类型的变量。



2、存放引用类型数组在内存中如何储存

先来再看一段存储引用类型数组的实例：



class Person {
    public int age;
    public String name;
    public void display() {
        System.out.println(name + "的年龄是: " + age);
    }
}
public class TestReferenceArray {
    public static void main(String[] args) {
        //1.定义数组
        Person[] persons;
        //2.分配内存空间
        persons = new Person[2];
        //3.为数组元素指定值
        Person p1 = new Person();
        p1.age = 28;
        p1.name = "Miracle";
        Person p2 = new Person();
        p2.age = 30;
        p2.name = "Miracle He";
        persons[0] = p1;
        persons[1] = p2;
        //输出元素的值
        for(Person p : persons) {
            p.display();
        }
    }
}

元素为引用类型的数组，在内存中的存储与基本类型完全不一样。 

此时数组元素存放引用，指向另一块内存，在其中存放有效的数据。如图：



了解数组和普通对象的引用变量：数组和普通对象的引用变量有什么区别

步骤依次如下：

设置断点——进入调试状态——点击上方调试选项卡——窗口——内存——内存1

Ps：一定要进入调试状态才可以哦！



然后，在下方就会有内存的窗口了！

最左边的是内存地址 右边是对应的内容



那么如何查看具体变量在哪块内存呢？

取地址啦~如下图：

在搜索栏用&取a的地址，然后回车就可以啦！（搜索栏是可以识别表达式的）



赋值操作完成后，对应地址的值就变化了哦！



另外再提，内存中的值是用16进制储存的 所以两个位一个单位，是一个字节

int 是4字节 即 a=0x0000 0001 细心的你可能会发现 内存里明明不是我写出来的0x0000 0001啊！
其实这又牵扯到另外一个东西，数据的储存是大端还是小端

大端即高位存高地址，小端反之

没必要去特意地记

知道大端是正常人的认知顺序，小端是反人类的认知顺序就行了

我的PC也就是这反人类的小端
红色部分的 01 00 00 00 应该从最右边开始读取

00 00 00 01
注意！不是逆序读 是从右边开始 以一个字节位为单位读

像逆序 00 00 00 10 这是错误的读法

嘻嘻 大概就这些东西啦！