装箱：

把一个基本类型赋值给一个Integer（引用类型对象）进而形成一个基本类型包装类对象。

Integer i=100；//装箱=Integer.valueOf(100);

System.out.println(i );

拆箱：

续上代码：i+=100;//i=i+100；

把一个引用类型i跟基本类型100进行运算（此时系统自动将i转换成一个基本类型）进而形成把一个基本类型包装类对象转换成一个基本类型shu'ju。

相当于：i.intValue()+100;

1.如果是一个很大的整数的话，比如：

long age=10000000000000000；

此时会报错；

所以使用BigInteger ：表示一个很大的整数↓

BigInteger bi=new BigInteger（“10000000000000000”）；

--因为这里传递的是字符串，所以没有范围限制；

2.BigInteger的构造方法：

BigInteger bi=new BigInteger（）；

但是：

要是用valueOf传递的话，有缺点，因为valueOf传递的是long类型，假如传递的是太大的数就传递不过去（当我们写一个数的时候，我们会有一个默认的类型去存储。一个整数的默认类型是int，但是传递的是100000000000，int类型存储不下）有范围限制。

BigInteger bi=BigInteger.valueOf（）；

1.

对整数的一个包装类↑↑

2.

intValue这个方法把Integer的i2对象zhuan'haun成一个整型数。

3.

int number=Integer.parseInt("100");

System.out.println(number);

把字符串传换成int类型就可以做数值运算。

4.

String numberStr=Integer.toString(100);

System.out.println(numberStr);

5.numberStr=100+"";----把一个数字加上一个空字符串，就可以把这个数转换成字符串。

6.把一个整数转换成一个包装对象方法：

--Integer.valueOf(100);

------------------------------------------------

构造Integer有两种方式：

--Integer i2=new Integer（100）；

--i2=Integer.valueOf(100);

--i2=Integer.valueOf("100");//来一个整数字符串

所以：valueOf可以为Integer构造一个对象并且可以传递一个数字或字符串。

------------------------------------------------

通过BigDecimal做精确的加减乘除运算：

--创建方式：

 1.BigDecimal number1=new BigDecimal（“0.05”）；//因为是字符串类型，所以无论如何传递的就是0.05

2. BigDecimal number1=BigDecimal.valueOf（0.01）；//valueOf对0.01做了精度处理

 3.BigDecimal number3=new BigDecimal（0.05）；//0.05在这里表示double类型，故传递数值不准备，输出结果为：0.0500000000000000277555等等。

--运算

BigDecimal result1=number1.add(number2);

BigDecimal result1=number1.subtract(number2);

BigDecimal result1=number1.multiply(number2);

BigDecimal result1=number1.divide(number2);

1.Math只有两个常量：PI和E，其他都是构造方法。

2.--04：34

System.out.println(Math.abs(-3.4));--取-3.4的绝对值

--04：46

System.out.println(Math.round(3.4));--取3.4的四舍五入

--05：23

System.out.println(Math.sqrt(4));--取4的平方根

--06：10

System.out.println(Math.pow(2，3));--取2的3次方

--07：12

System.out.println(Math.ceil（3.1）);--向上取整3.1--4

--08：00

System.out.println(Math.floor（3.1）);--向下整取3.1--3

--08：25

System.out.println(Math.max（435，3）);--取435和3的最大值

--09：00

System.out.println(Math.min（435，3）);--取435和3的最小值

------------------------------------------------System.out.println(Math.random（）);--生成随机数（范围：【0，1），意思是大于等于0小于1）

要想生成【0，5）之间的随机数，System.out.println(Math.random（）*5);即可。--【0，5）

--要想取得【0，5）之间的整数，那么把生成的随机数向下取整即可：

System.out.println(Math.floor（Math.random（）*5）);

或者：System.out.println（（int）(Math.random（）*5）);--强制转换成整数int

--要想取得【6，8）之间的整数：

System.out.println（（int）(Math.random（）*3）+6);-

1.Arrays不需要构造，因为里面都是静态方法。

2.要对一个数组排序（sort方法），那就要对该数组进行遍历：

for（int i：a）

3.int index=Arrays.binarySearch（a，23）；

意思就是在a数组查找23的索引，并把这个索引传递给index。

4.

StringBuilder和StringBuffer不同点：

1.前者线程安全（适用多线程），性能略低；后者线程不安全（bu适用多线程），性能略高；

线程安全&不安全：

线程多，效率高，但是共用性高，有可能造成资源冲堵，不安全。

StringBuffer还有delete功能：

StringBuffer sb1=new StringBugger("sikiedu");

sb1.delete(0,3);

-----该删除功能会删除索引为0开始，索引为2结束的字符，但不包括索引为3的字符。

StringBuffer还有insert功能：

sb1.insert（3."www"）；

-----该插入功能会在索引为3前面把www插入。

StringBuffer还有substring功能：

sb1.substring（0，6）；

---截取方法对指范围字符串截取后返回一个新的StringBuffer对象，对原有StringBuffer对象不做影响。（所以输出还是原有字符串）

StringBuffer还有replace功能：

sb1.replace（3，5，"--"）；

---替换方法包含开始索引，不包括结束索引：3跟4索引的字符串替换成--，5索引保持不变。

1.StringBuffer不止可以追加字符串，还可以追加字符、整型数字、boolean类型（true、false）。

2。无论调用多少个append，最终一直在处理的对象（内存区域）也还是append的对象。简称“链式编程。

所以调用了append后，用==判断两个字符串的时候，返回的是true。

当我们没有给StringBuffer赋值的时候，可以利用capacity查看其容量（因为其容量的分配都是依据传入字符串的长度定义）

StringBuffer sb1=new StringBuffer();

System.out.println(sb1.capacity());

-----输出结果会是16，意思就是说其容量能够存放16个字符。

StringBuffer：可以创建一个可以被修改的字符串（StringBuffer属于java.lang，所以不用引用java.lang，直接使用StringBuffer即可）

append：追加

String也可以追加：(对于String而言，追加不是把一个放在另一个的内存区域后面，因为String内容不可修改，而是把两个对象复制到同一块新的内存区域里面实现追加功能)

String s="sikiedu";

s+=".com";

而StringBuffer声明之后，它在内存区域所占较大，它不止于能够存放传递字符串，还可以在同一块内存区域存放追加字符串。

**---给字符串s声明值的方法---**

String s="sikiedu.com";

String s=new String("sikiedu.com")；

String s=new String(new char[] {'s','k','i','e','d','u','.','c','o','m'});

**------------------------------**

以上第三种方法是传递字符数组，他会把字符数组里面的字符拼接起来成一个字符串并传递给String s。

1.String：声明的字符串不能修改（内容无法修改，引用可改）

StringButter&StringBuilder：声明的字符串能修改

2.ctrl+alt+n:快速复制一行

1.ctrl+shift+o：自动引入类

2.String str=s.next();---接收用户输入的字符串

3.int i=s.nextInt();---接受用户输入的整型数据

4.isHasNext（）；用法：

因为isHasNext（）是boolean类型，假如用isHasNextInt（）；我们在控制台输入一个字符串，那么他会输出false，在控制台输入一个整型数据，那么输出true。

5.hasNext是用来判断，next用来接收：

1.要想引入别的工程的包，必须对别的工程的包当成一个jar包导出，然后在要引入该工程的包的工程导入这个jar包。

只要new，无论new里面的参数是否一致，都会在堆里面申请新的内存区域。而且，==比较的是内寸地址，因为s1跟s2的内存地址不一样，所以最后结果输出：false

为什么字符串里面的equals比较的是数据？

因为字符串是系统的一个类，系统把equals这个方法重写了，让这个equals去比较数据。

重写代码:

public boolea equals(Student s){

if(this.age==s.age&&this.name.equals(s.name)){

return true;}

else{

return false;

}}

-----this.age指的是当前对象；s.age指的是要比较的对象

比较：

1、==（用于基本类型的比较使用）

2、equals（用于引用类型的比较使用）

==：比较应用类型的时候，==是用来比较引用

构造类型不一样，new出来的对象在堆里面申请内存区域，String s1会在栈中出现，指向堆中首地址为078的内存区域，也就是new出来的对象在堆里面申请内存区域。而定义一个常量www.sikiedu.com是存放在静态区。

s1里面的078指向堆中的078，堆中的078内的089指向静态区的089。

假如不是用==，是用equals

1.创建类的时候，abstract和final不能同时选择（abstract是抽象类，它必须要被继承才能使用；final不能被继承）二者矛盾

2.public和package二者在创建的时候区别：

public：公开，在任何地方都能使用；

package：默认的（default），只能在当前包使用

3.假如一个类没有父类，那么默认它是继承自java.lang.Object这个类。

所有类都是从Object派生出来，Object是所有类的父类。而Object这个类是在java.lang这个包里面，但是这个包不需要引用，直接使用包内的类即可。

当我们把一个引用类型的对象当作字符串输出的时候，系统会默认调用toString（）方法，所以System.out.println(s);的运行结果等同于System.out.println(toString()); 

toString（）这个方法默认的作用就是取得对象的内存地址（引用）。

toString（）这个方法返回的是字符串，如果不想输出内存地址，可以对toString（）这个方法进行重写：

1.ctrl+shift+F：自动排序（f：format）

2.ctrl+up（down）：切换上一个项目（下一个项目）

3.选中一行代码，按住alt+上下任意方向键对选中代码进行位置的上下调整。

4.ctrl+/  :单行注释；ctrl+shift+/ ：多行注释

System.err.println("");

-----输出内容字体颜色会因为err而变成红色