java 变量和运算符

一、变量

#1、数据类型

四类八种

类型名称	数据类型	占用内存	取值范围
字节型	byte	1个字节	-2^7 ~ 2^7-1
短整型	short	2个字节	-2^15 ~ 2^15-1
整型	int	4个字节	-2^31 ~ 2^31-1
长整型	long	8个字节	-2^63 ~ 2^63-1
单精度浮点型	float	4个字节	（正数）1.4E-45 - 3.4028235E38 （整体） -3.4028235E38 ~ 3.4028235E38
双精度浮点型	double	8个字节	1.7976931348623157E308 ~ 4.9E-324
字符型	char	2个字节	65536（看字符编码）
布尔型	boolean	1个字节	两个值 true和false

####（1）整形的取值范围

byte是一个字节，一共八位，第一个是符号位，所以用于表示数值的只有7位。

所以他的取值范围是：-2^7 ~ 2^7

（2）浮点数的取值范围

浮点数的表示，难点，不理解就算了

根据国际标准IEEE 754，任意一个二进制浮点数V可以表示成下面的形式： V = (-1)^s×M×2^E

1. (-1)^s表示符号位，当s=0，V为正数；当s=1，V为负数。

2. M表示有效数字，大于等于1，小于2，但整数部分的1可以省略，也叫尾数。

3. 2^E表示指数位。

   符号位

   只有两个取值0或者1，0代表正数，1代表负数。

   阶码

E为一个无符号整数（unsigned int）,这意味着，如果E为8位，它的取值范围为0_{255；如果E为11位，它的取值范围为0}2047。然而科学计数法中的E是可以出现负数的，所以IEEE 754规定，E的真实值必须再减去一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。 比如，2^2的E是2，所以保存成float 32位浮点数时，必须保存成2+127=129，即10000001。

尾数

M可以写成1.xxxxxx的形式，其中xxxxxx表示小数部分。IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。比如保存1.0101的时候，只保存0101，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。

小例子：-58.2在内存是怎么表示的

System.out.println(Integer.toBinaryString(Float.floatToIntBits(-58.2F)));
//结果：1 10000100 11010001100110011001101

其实可以写成 -1 * 1.11010001100110011001101 * 2^（132-127） = -1.11010001100110011001101*2^5 = 111010.001100110011001101

是不是相当与小数点向后移动5位啊

-1 * 111010.001100110011001101 大约等于 -58.2

（3）char的取值范围

简单的聊聊字符编码：

思考：如果用

ASCII

（American Standard Code for Information Interchange，美国信息互换标准代码）

ASCII第一次以规范标准的类型发表是在1967年，最后一次更新则是在1986年，到目前为止共定义了128个字符。ASCII码，用一个字节表示，8位能够表示256个字符，可以用来表示所有的大写和小写字母，数字0到9、标点符号，以及在美式英语中使用的特殊控制字符，足够美国人用的了，事实上他们只用到了128个字符，还有位就空着了。

Unicode

Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，规定虽有的字符和符号最少由 16 位来表示（2个字节），即：2 ^16 = 65536（注：此处说的的是最少2个字节，可能更多）。

GB2312

把中国单独拉出来看，MBCS时期，中国于1980年发布了GB2312，就是国标的拼音，这个编码用区位码（94个区，每区94个字符）的方式可以支持7000多个汉字，它所收录的汉字已经覆盖中国大陆99.75%的使用频率，基本可以满足汉字计算机的需要了。

• gb2312 是简体中文的码
• gbk 支持简体中文及繁体中文

UTF-8

UTF-8，是对Unicode编码的压缩和优化，所以UTF-8包含于Unicode，只是他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存

查看咱们的字符集

import java.nio.charset.Charset;
public class Demo {
    public static void main(String[] args) {
        System.out.println(Charset.defaultCharset());
    }
}

包装类和String类的详解

包装类
含义：基本数据类型对应的类。

出现的原因：

java为纯面向对象的语言（万物皆为对象），而八种基本数据类型不能创建对象，破坏了java为纯面向对象语言的特征，所以java又给这八种数据类型分别分配了对应的类，这种叫做包装类/封装类。

继承关系：

基本数据类型 引用数据类型

注意：

数值都是继承Number
int的包装类是Integer
char的包装类Character

装箱拆箱

装箱： 把一个基本数类型 变成引用 数据类型

拆箱： 把引用数据类型变成 基本数据类型

	
/**
*装箱：基本数据类型 ——>包装类
*/
	int i;
	Integer integer = Integer.valueOf(i);//装箱
	System.out.peintln(i);

/**
*拆箱：包装类 ——> 基本数据类型
*/
	Integer integer = new Integer(100);
	int i = integer.valueOf();//拆箱
	System.out.println(i);
	
//JDK1.5的新特性：自动装箱、自动拆箱
/**
*自动装箱：基本数据类型 -> 包装类
*/		       
	int i = 100;
	Integer integer = i;//自动装箱（底层实现：Integer.valueOf(i);）
	System.out.println(integer);
		
/**
*自动拆箱：包装类 -> 基本数据类型 
*/		  		
	Integer integer = new Integer(100);
	int i = integer;//自动拆箱（底层实现：integer.intValue();）
	System.out.println(i);

应用场景：集合(类似数组的容器)，但是集合只能存引用数据类型，如果想存储基本数据类型，就可以把基本数据类型转换为对应的包装类对象

需求：把字符串数组{"1","2","3","4","5"}转换为int数组

	String[] ss = {"1","2","3","4","5"};
	
	int[] is = new int[ss.length];
	
	for (int i = 0; i < is.length; i++) {
		//1.将String转换为Integer对象
		//2.Integer对象自动拆箱成int数据
		int num = Integer.valueOf(ss[i]);
		
		is[i] = num;
	}
	
	for (int element : is) {
		System.out.println(element);
	}

String类

不可变字符

不可变字符串指的是，一个字符串对象内容一旦赋值，不可再变化。如果对其拼接，其实就会创建一个新的字符串，然后这个引用指向了这个新的字符串。

String类

String 类是一个常用基础类型，但是引用数据类型，被设计为一个不可变字符串，位于java.lang包下。

String 创建方式

1. String(String xx)
2. String xx = “字符串内容”;

String 常用API

	String str = "123abc";
	
	str = str.concat("DEF123");//在此字符串末尾追加字符串，并返回新的字符串
	str = str.substring(2);//从开始下标处截取到字符串末尾，并返回新的字符串
	str = str.substring(1, 7);//从开始下标处(包含)截取到结束下标处(不包含)，并返回新的字符串
	str = str.toUpperCase();//转大写，并返回新的字符串
	str = str.toLowerCase();//转小写，并返回新的字符串

---

	str = "   123 a  bcD EF 123        ";
	
	str = str.trim();//去除首尾空格，并返回新的字符串
	str = str.replace('2', '-');//替换字符，并返回新的字符串
	str = str.replaceFirst("3", "小明");//替换第一个出现的字符串，并返回新的字符串
	str = str.replaceAll("1", "xxx");//替换字符串，并返回新的字符串
	str = str.replaceAll(" ", "");//替换字符串，并返回新的字符串

	System.out.println("判断两个字符串内容是否相同：(区分大小写)" + str.equals("xxx-小明abcDEFxxx-3"));
	System.out.println("判断两个字符串内容是否相同：(不区分大小写)" + str.equalsIgnoreCase("XXX-小明ABCdefxxx-3"));
	System.out.println("判断此字符串是否以某个字符串开头：" + str.startsWith("xxx"));
	System.out.println("判断此字符串是否以某个字符串结尾：" + str.endsWith("-3"));
	
	System.out.println("查询此字符串第一次在目标字符串中的下标：" + str.indexOf("-"));
	System.out.println("查询此字符串最后一次在目标字符串中的下标：" + str.lastIndexOf("-"));
	
	System.out.println("获取指定下标上的字符：" + str.charAt(4));

	//xxx-小明abcDEFxxx-3	
	System.out.println(str);

注意：String是一个不可变的类， 即一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的, 直至该对象被销毁。

	//将其他类型转换为字符串
	
	int i = 100;
	System.out.println(String.valueOf(i));
	
	boolean bool = true;
	System.out.println(String.valueOf(bool));

2、定义变量

变量就是一切通过内存分配并赋值的量，分为不可变变量和可变变量

变：能保存一些可变的量，比如年龄，收入等

便： 方便，一次定义，“到处”（作用域内）使用

####（1）过程

• 定义 int i;
• 赋值 i = 5; 定义和赋值可以一起 int i = 5;
• 使用；

（2）定义变量的规则

1. 变量名字里不能有空格。

2. 避免使用关键字，class public int static

3. 避免使用汉字，不要使用英文和拼音混着写

4. 整体是驼峰命名，首字母小写 lowerCamelCase

5. $和_可以到处使用，但是不建议当做开头

6. 数字不能开头

3、基础数据类型的运算

####（1）算术运算符

  +  -  *  /   %    ++   -- 

i++，--i 其实相当于 i = i+1;

int num1 = 12;
++num1;
System.out.println(num1);

结果是13

int num1 = 12;
num1++;
System.out.println(num1);

结果是13

int a =11;
System.out.println(a++);

结果是11

int a =11;
System.out.println(++a);

结果是12

int num1 = 12;
int num2 = num1++;
System.out.println(num2);

结果是：12
先赋值后计算

int num1 = 12;
int num2 = ++num1;
System.out.println(num2);

结果是：13
先计算后赋值

看看以下的代码：

int num1 = 12;
int num2 = 13;
int num3 = num1 + num2;
System.out.println(num3);
结果是：25

结论：

算术运算符，int以下的做运算，结果都是int类型，long和其他的类型做运算，结果是long。

++i 和 i++的区别

如果不赋值都是自增1

如果赋值，i++ 是 先把i赋值给其他变量，然后自增， ++i是先赋值再自增。

（2）逻辑运算符-真值表

逻辑运算的结果是布尔型 boolean 与 或 非

与

条件1 condition1	条件2 condition2	结果
true	true	true
true	false	false
false	true	false
false	false	false

或

条件1 condition1	条件2 condition2	结果
true	true	true
true	false	true
false	true	true
false	false	false

非

条件1 condition1	结果
true	false
false	true

符号表示

& | ！ && ||

		boolean flag1 = true;
		boolean flag2 = false;
		
		boolean flag3 = flag1 & flag2;
		boolean flag4 = flag1 | flag2;
		boolean flag5 = !flag1;
		
		
		int num1 = 12;
		int num2 = 15;
		boolean flag6 = num1 >= num2;
		boolean flag7 = num1 == num2;
		
		
		boolean flag8 = (num1 >= num2) & (num1 == num2);
		
		System.out.println(flag8);

短路运算符

&& 短路运算符 如果短路运算的结果是false，那么结果直接就是false， 不会继续运算后边的逻辑

|| 短路运算符 如果短路运算的结果是true，那么结果直接就是true， 不会继续运算后边的逻辑

看看以下代码:

byte num1 = 12;
byte num2 = 13;
byte num3 = num1 & num2;

byte num1 = 12;
long num2 = 13;
long num3 = num1 & num2;

char c1 = '1';
char c2 = '2';
char c3 = c1 & c1;

System.out.println('a');
System.out.println('a'+'b');

亦或

^ 相同为零 不同为1

（3）赋值运算符号

+= -= *= /= =

i += 5 相当与 i = i + 5;

（4）三目运算符

条件 ？ 结果1 ： 结果2；

条件的结果一定是boolean ，只能是true或者false；

条件是可以复杂的

boolean condition1 = 5 > 3;
boolean condition2 = 5 > 3;
boolean condition3 = 5 > 3;
int num = (condition1 && (condition2 || condition3)) ? 1 : 2;

（6）位移运算符

符号	说明
<<	左移运算符，将运算符左边的对象向左移动运算符右边指定的位数（在低位补0）
>>	"有符号"右移运算 符，将运算符左边的对象向右移动运算符右边指定的位数。使用符号扩展机制，也就是说，如果值为正，则在高位补0，如果值为负，则在高位补1.
>>>	"无符号"右移运算 符，将运算符左边的对象向右移动运算符右边指定的位数。采用0扩展机制，也就是说，无论值的正负

4、数据类型的转型

int类型的变量转long，怎么转，自动转。

int num1 = 152;
long num2 = num1;
System.out.println(num2);

long类型的变量转int，怎么转，强转。

long num1 = 2345645645645464564L;
int num2 = (int)num1;
System.out.println(num2);

float类型转long

float num1 = 234545654654654564564564.4F;
long num2 = (long)num1;
System.out.println(num2);

long类型转float

long num1 = 2345645645645464564L;
float num2 = num1;
System.out.println(num2);

结论：

任何有精度缺失（有可能让两个数变成完全不一样的两个数）的转型都需要强转，jvm不给你负责。

取值范围大的转取值范围小的自动转，反之需要强转。