Java SE 学习笔记
跨平台性
1，通过java语言写的应用程序可以在不同的系统平台上运行。
2，只需要在相应的系统平台上下载JVM（虚拟机）就可以通用。
3，java语言有跨平台性但是，JVM没有跨平台性，有很多种类，每一个系统的JVM是不相同的。
JRE（java运行环境）
JDK（java开发工具包）
JDK包含了JRE
写程序的步骤
1，首先定义一个类
class后面空出一格打上你自己对它的命名。
2，在定义的类后面打上一个大括号
{ }
3，在大括号中添加一个主函数（main）
public static void main(String[ ] args){}。
4，在主函数的大括号中添加比如输出语句
System.out.println("你好，世界") ；
程序解析
1，首先编写java的源代码程序 拓展名.java
2，在命令行模式中，输入javac命令对源代码进行编译，生成字节码文件
3，编译完成后，如果没有报错信息，输入java命令对class字节码文件进行解释运行，执行时不需要添加.class拓展名
java Demo
关键字
1，被Java语言赋予特殊含义的单词
2，关键字特点： 组成关键字的字母全部小写
3，在一些编译器中，关键词都会有特殊的颜色标识，很容易辨认
标识符
1，标识符概述
就是给类，接口，方法，变量等起名字时用的字符序列，
2，组成规则
英文大小写字母
数字字符
$和_
3，注意事项
不能以数字开头
不能是java中的关键字
区分大小写
不能有空格
4，标识符（常见命名规）
注意事项:见名知意
举例：假如要创建一个学生类，
那么：class Student { }
包 ：其实就是文件夹，用于解决相同类名问题（就像是解决同一目录下不能存在两个相同名字的文件)
包的命名全部小写
单级：比如：李信良
多级：比如：物联网2001.李信良 （ 中间的点起到了一个分级的作用 ）
类或接口：
一个单词组成：单词的首字母必须大写。
多个单词组成：每个单词的首字母都必须大写（比如HelloWord)。
方法或者变量：
一个单词组成：单词的首字母小写（比如main）
多个单词组成：从第二个单词开始，每个单词首字母大写（比如studentAge)
常量：
一个单词组成：全部都要大写。
多个单词组成：每个单词都大写，中间用_（下划线）隔开。
注释
1，用于解释程序的文字。
2，java的注释分类格式：
单行注释：//注释文字
多行注释：/ 注释文字 /
文档注释：/ 注释文字 * / 被Javadoc工具解析生成一个说明书，面向对象部分讲解
注意这样的注释方法是错误的，第一行和第
六行算是一个多行注释，所以第七行会报错。
单行注释可以嵌套，但是多行注释不可以被嵌套
注释是一个程序员必须要有的良好编程习惯
初学者可以养成先写注释，再写代码的习惯
将自己的思想通过注释先整理出来，再用代码去体现，因为代码是思想的一种体现形式
/main方法是主方法是程序的入口，被JVM调用/
常量
1，常量概述
在程序执行中，它的值不可以发生改变
2，java中常量分类
字面值常量：
字符串常量（用双括号括起来的内容）
整数常量（所有整数）
小数常量（所有小数）
字符常量（用单括号括起来的内容）
布尔常量（较为特有，只有true，false）
空常量（null）
自定义常量
3，Java针对整数常量提供了4种表现形式
二进制
八进制
十进制
十六进制
4，二进制到八进制的转化
把二进制的数据从右开始，每三位一组合，最左边不够的时候，用0补够三位，然后分别计算出对应的十进制数值，最后，在把 每个十进制的数据组合起来，就是一个八进制数据。
这种表现形式还不是最简单的
把二进制的数据，从右开始，每四位一组合，最左边不够的时候，补0，然后计算出对应的十进制数值，最后，在把每个十进制 的数据组合起来，就是一个十六进制的数据。
进制越大，表现形式越短。
5,不同进制的数据组成
二进制：由0，1组成。以0b开头
八进制：由0，1，2，3，4，5，6，7组成。以0开头。
十进制：由0，1，2，3，4，5，6，7，8，9组成。整数默认是十进制的。
十六进制：由0，1，2，3，4，5，6，7，8，9，a,b,c,d,e,f（大小写均可）组成。以0x开头组成。
6，进制的转换
其他进制到十进制： 位权展开乘 法十进制到其他进制的转换：（位权展开除法)
二进制到八进制的快速方法：
从右向左每3位为一组，最后不够的补0，每组分别化成10进制的数，就得到了8进制的数据。
7，有符号的数据表示法 （ / 计算机在操作的时候都是采用数据对应的二进制的补码来进行运算的 /）
在计算机内，有符号数具有三种表示法：原码，反码，补码，所有数据的运算都是按补码进行的
源码：
就是二进制定点表示法，即，最高位为符号位，‘0’表示正，‘1’表示负，其余位表示数值的大小。
反码：
正数的反码与其原码相同，负数的反码就是源码的每一位都取反，符号位除外
补码：
正数的补码与其原码相同，负数的补码是在反码的末尾加‘1’。
8，数据类型
java是一种强类型的语言，针对每一组数据都定义了明确的数据类型
数据类型分类：
A：基本数据类型
B:引用数据类型（类，接口，数值）
基本数据类型：四类八种
A：整数byte 1
short 2
int 4
long 8
B：浮点数
float 4
double 8
C：字符
char 2
D：布尔
boolean 1
+是一个运算符，做数据的加法
boolean类型不能转化成其他的数据类型
默认转化：
强制转换：
数组的概述
1，数组的概念：
数组是存储多个变量（元素）的东西（容器）
这多个变量的数据类型要一致
数字既可以存储基本数据类型，也可以存储引用数据类型
数组一旦初始化完成，其长度就已经确定了
2，数组的定义格式
格式一：数据类型 [ ] 数组名 定义一个
格式二：数据类型 数组名 [ ]
<ins>现在大部分都使用格式一来进行书写<ins>
3，数据的初始化
Java中的数组必须先初始化，然后才可以使用。
初始化就是给数组中的数组元素分配内存空间，并为每个数组赋值。
4，数组的初始化方式
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化:初始化时指定每个数组元素的初始值，有系统决定数组长度。
这两种方式不可以同时存在。
5，动态初始化
格式：数据类型 [ ] 数组名 = new 数据类型[数组长度] ;
数组的长度其实就是数组中的元素个数
举例：
上面的这个例子运行后会生成一个地址值，但是我们不需要用地址值。
所以，数组中的每一个元素都是有编号的，并且是从0开始，最大的编号是数组的长度减一。
用数组名和编号的配合就可以获取数组中指定编号的元素。
这个编号的专业叫法：索引。
通过数组名访问数据的格式是：数组名[索引]；
循环
while循环和do whlie循环的区别
对于whlie循环来说，如果不满足条件，那就不进入循环
但是对于do while来说，这个循环至少会循环一次
条件语句
if的一些独特的用法
有一些特殊的if的条件语句需要比较注意，
格式是：if（布尔表达式）
System.out.println("a");
System.out.println("b");
数组的操作
1，遍历
依次输出数组中的每一个元素
可以使用for循环结合索引就可以输出所有的值
查询数组的长度用：数组名.length（可以返回数组的长度）
2，获取数组中的最值
同样的，使用for循环，再加上判断语句，就可以判断
3，数组元素逆序（就是把数组的元素对调）
4，数组元素的排序
就是用求先把第一位和第二位比较，如果前面的大，那他们两就要交换位置
注意交换位置的时候，要引用一个中间量，否则没有办法正常交换
这样重复一次又一次后，每次都把最大的放在了后面
就可以把这个数组排序
5，杨辉三角的书写
杨辉三角的本质是这这个值等于这一列的上一行的前一列数字加上这一列的数字
###
Java中的内存分配
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特 定的处理数据方式和内存管理方式。
栈：储存局部变量 堆：储存new中的东西
方法区：（面向对象部分详细讲解）
本地方法区：和系统有关
寄存器：给cpu使用
1，局部变量
在方法定义中或者方法声明上的变量都称为局部变量。
图片理解：
2，堆内存的特点
A：每一个new出来的东西都有地址值（这个地址值一般是一个16进制的数值）
B：每一个变量都有默认值：
byte，short,int,long, 0
float,double 0.0
char \u0000
booolean false
引用类型 null
C：使用完毕就变成了垃圾，但是没有立即回收。会在垃圾回收器空闲的的时候回收。
3，栈内存的特点
用完就会被清理掉
java面向对象
1，面向对象思想引入
前面我们讲过，我们可以把程序封装到方法中，以来提高程序的复用性，而方法又可以封装到类中，所以当我们再做一些操作 时,不用去找具体的方法，先找到这个类，在使用这个类中的方法，这就是面向对象思想的编程方式
2，概念
对于java语言来说，一切皆是对象。把现实世界中的对象抽象的体现在编程世界中，一个对象代表了某个具体的操作。一个个 对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递 信息，实现程序开发。
3，对象的概念
所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的 概念
4，对象的特点
对象具有属性和行为
对象具有变化的状态
对象具有唯一性
对象是某个类别的实例
一切皆为对象，真实世界中的所有东西都可以视为对象
例如，在真实世界的学校里，会有学生和老师等实体，学生有学号，姓名，所在班级等属性（数据），学生还有学习，提问， 吃饭和走路等操作，学生只是抽象的描述，这个抽象的描述称为类，在这个学校里活动的学生是个体，即张同学，李同学，这 些个体称作“对象”，“对象”也称为“实例”
5，面向对象的三大核心特征
1，优点
1，可重用性：代码重复使用，减少代码量，提高开发效率
2，可拓展性：指新的功能可以很容易的加入到系统中来，便于软件的修改
3，可管理性：能够将功能与数据结合，方便管理
2，特点
1，继承性：如同子女继承父母一样，这里的继承性是指子类具有父类的全部特征和行为，这是类之间的一种关 系，java只支持单继承（单继承就是说，只能有一个父类）
2，封装性：封装是将及其处理的数据和程序绑定在一起的一种编程机制，该机制保证了程序和数据都不受外部 干扰且不被误用。封装的目的在于保护信息，他的优点如下：
1，保护类中的信息，它可以阻止在外部定义的代码随意访问内部代码和数据。
2，隐藏细节信息，一些不需要程序员修改和使用的信息，比如取款机中的键盘，用户只用知道按那个键可 以实现什么操作就可以，至于内部如何运作，用户不需要知道。
3，有助于建立各个系统之间的松耦合关系，提高系统的独立性当一个系统的实现方式发生变化时，只要他 的接口不变就不会影响其他系统的使用，比如U盘，不管里面的储存方式如何改变，只要usb接口不发 生变化，就不会影响用户的正常操作。
4，提高软件的复用率，降低成本。每个系统都是一个相对独立的整体，可以在不同的环境中得到使用，
比如，一个upan可以在多台电脑中使用。
3，多态性：面向对象的多态性，即“一个接口多个方法”。多态性体现在父类中定义的属性和方法被子类继承 后，可以具有不同的属性或表现方式，多态性允许一个接口被多个同类使用，弥补了单继承的不足 ，比如老师类中的多个属性和方法可以被数学老师和语文老师同时使用。这样也不易出错。
6，面向对象开发
就是不断的创建对象，适用对象，指挥堆箱做事情。
7，面向对象设计
就是在管理，使用对象之间的关系。
（编程语言是为了模拟现实世界中已有的东西，java中最基本的单位是类)
事物的属性和行为就相当于类中的成员变量和成员方法
类：是一组相关的属性和行为的集合。
对象：是该类事物的具体表现形式，是具体存在的个体。就比如学生就是类，班长就是一个具体的对象
定义一个类就是定义该类的成员变量和成员方法。
成员变量：和以前变量的定义是一样的格式，但是位置不同，在类中方法外。
成员方法：和以前的方法定义是一样的格式，但是今天把static先去掉
首先我们定义一个类，然后完成类的成员（用class来定义类）
类如何使用呢？创建对象使用。如何创建对象呢？格式：类名 对象名 = new 类名 （ ）；如何使用成员变量呢？格式：对象名.变量名；如何使用成员方法呢？格式：对象名.方法名（中间放参数）
如何给成员变量赋值？对象名.变量名= ；
方法可以直接调用
成员变量和局部变量的区别
在类中的位置不同
成员变量：类中方法外
局部变量：方法内或者方法声明上
在内存中的位置不同
成员变量：在堆内存中
局部变量：在栈内存中
生命周期不同
成员变量：随着对象的存在而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
成员变量：有默认的初始化值
局部变量：没有默认的初始化值，必须先定义，赋值，才能使用
形式参数和实际参数
public static void add(int a,int b){
int x=1;
int c;
c = a + b;
sout(c);
}
在上面的方法中，a,b就是形式参数，并且要注意的是，这里的c是变量，不是参数，x就是实际参数
形式参数的问题
基本类型：形式参数的改变不影响基本类型
引用类型：形式参数的改变直接影响实际参数
如果你看见了一个方法的形式参数是一个类类型（引用类型），这里其实需要的是该类的对象
基本类型给对应的值就OK了，但是引用类型实质上给的是一个地址值，如果要使用就要创建该形式参数类的一个对象
在后面讲过匿名对象以后，就会有更好的办法去调用引用类型，在有多个传递的时候，使用匿名对象的效果就很好
赋值运算符
基本的赋值运算符：= 。
扩展的赋值运算符：+=（把左右两边想加，然后赋值给左边），-=（把左右两边相 减，然后赋值给左边），*=（把左右相乘，然后赋值给左边），/=（把左右相除， 然后赋值给左边），%=（给左右取余，然后赋值给左边） 。
例题：short s=1 ； s=s+1 ;
short s=1 ； s+=1 ;
上面两个代码有没有问题，如果有，哪里有问题？
第一个代码有问题，因为s+1是2,2不等于1
匿名对象
匿名对象：就是没有名字的对象
是对象的一种简化的表现形式
匿名对象的两种使用情况
对象调用方法仅仅一次的时候
作为实际参数传递的时候
格式
正常格式：student s = new student( );
匿名对象的格式：new student( );
匿名对象调用方法
new student( ).方法名（）;
注意：
s.方法名（）；
s.方法名（）；
new student( ).方法名（）;
new student( ).方法名（）;
他们的含义是不一样的，前两行的意思是，同一个对象调用两次，而后两行的意思是，两个不同的对象被调 用了两次，匿名对象只能使用一次，这就是为什么结果一样但是含义不一样的原因。
匿名对象的好处
匿名对象调用完就是垃圾，可以被垃圾回收器回收。
线程安全（多线程讲解）
安全：同步，但是数据是安全的
不安全：不同步，但是可以使效率更高一些
但是安全和效率问题是永远困扰着我们的问题，一般我们只是选取一个方面，并且保证，尽可能的既安全又高效。
所以的话我们就要分实际情况来进行讨论，就比如银行的网站就是需要安全，但是论坛之类的东西，就更需要效率。
就比如说，两个人去银行取钱，一个在atm机上取，还有个在柜台上取，只有当一个人在操作时，另一个人无法操作，这才能是 安全的，如果不是这样，那两个人可以同时取钱，就会有安全隐患。
StringBuffer和String的区别
前者的长度和字符可变，后者String是不可变的对象。
所以每次在对String类型改变的时候其实就是又新生成了一个新的String对象，所以如果我们遇到需要经常改变内容的字符串最好不要使用String，这样就可以避免效率低下的问题。
如果使用前者做字符串的拼接，不会使用太多的资源。
StringBuffer的构造方法
public Stringbuffer( )
无参构造方法，构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符。
public StringBuffer(CharSequence seq)
构造一个字符串缓冲区，它包含与指定的CharSequence相同的字符。
public StringBuffer(int capacity) //这里的capacity是容量的意思
构造一个不带字符，但是具有指定初始容量的字符串缓冲区。
public StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
public int capacity( )
可以返回当前的容量。（一个水杯的容量，理论值）
public int length( )
返回长度（字符数）。（一个水杯中水的容量，实际值）
StringBuffer类的成员方法
添加功能(可以把任意类型添加到字符串缓冲区，并返回字符串缓冲区本身）
public StringButter append(String str) 添加的意思
public StringButter insert(int offset,String str) 插入的意思，可以在指定的位置添加
删除功能
public StringButter deleteCharAt(int index)
public StringButter delete(int start,int end)
替换功能
public StringButter replace(int start,int end,String str)
反转功能
public StringButter reverse( )
截取功能(截取功能和前面几个功能不同，返回值类型是String类型，本身没有发生改变)
public String substring（int start）
public String substring（int start,int end)
String和StringBuffer之间的相互转换
我们为什么要进行类之间的转换：我们从A转到B，一般是为了使用B的功能，从B转到A，可能我们需要的结果是A类型
不能把字符串的值直接赋值给StringBuffer
String如何到StringBuffer：方法一：通过构造方法：格式：String a = "你好世界"；StringBuffer = new StringBuffer(a);
方法二：通过append: 格式：先new一个StringBuffer，之后new StringBuffer().append(a);
StringBuffer如何到String 方法一：通过构造方法 格式:String str = new String(Buffer);
方法二：通过toString() 格式:String str = buffer.toString( );
把数组拼接成一个字符串
public static void main(String[] args) {
int[] arr = {4, 5, 1, 3, 7, 9};
String s2 = arrayToString2(arr);//起到了一个接收的作用
System.out.println(s2);
}
public static String arrayToString2(int[] arr){
StringBuffer sb = new StringBuffer();
sb.append("[");
for (int x = 0; x < arr.length; x++){
if (x == arr.length - 1){
sb.append(arr[x]);
}else {
sb.append(arr[x]);
sb.append(",");
}
}
sb.append("]");
return sb.toString();
}把字符串反转
public static void main(String[] args) {
//键盘录入数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入数据：");
String s = sc.nextLine();
//接收数据
String s1 = myReverse2(s);
System.out.println(s1);
}
public static String myReverse2(String s) {
/*StringBuffer sb = new StringBuffer(s);
*sb.reverse();
*return sb.toString();
*/
//更简单的方法：
return new StringBuffer(s).reverse().toString();
}判断一个字符串是不是对称字符串
/*
分析：panduanyigezifuchuanshibushiduichengzifuchuan；
我们应该把第一个数字和倒数第一个数字做比较；
再把第二个数字和倒数第二个数字做比较；
比较的次数应当是字符串的长度再除以2；
*/
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.nextLine();
//接收数据
Boolean b = bijiaoshifouxiangtong(s);
System.out.println(b);
Boolean b1 = bijiaoshifouxiangtong2(s);
System.out.println(b1);
}
public static boolean bijiaoshifouxiangtong(String s){
//（待解决）疑问：为什么要把字符串转化成字符数组？
char[] chr = s.toCharArray();
//接下来开始写算法
for (int start = 0, end = chr.length - 1; start <= end; start++,end--){
if (chr[start] != chr[end]){
return false;
}
}
return true;
}
public static boolean bijiaoshifouxiangtong2(String s){
//（待解决）疑问：为什么要把字符串转化成字符数组？
char[] chr = s.toCharArray();
boolean flag = true;
//接下来开始写算法
for (int start = 0, end = chr.length - 1; start <= end; start++,end--){
if (chr[start] != chr[end]){
flag = false;
break;
}
}
return flag;
}String和StringBuffer和StringBuilder的区别
StringBuffer和StringBuilder就是相似的，上面讲到的StringBuffer的方法对于StringBuilder都生效，他们两个的区别就是 StringBuffer更加安全，同样的他的效率就没有另一者高。
String与后面两者的区别就是，String是内容不可变的，但是后面的两个都是字符串长度可变的。
StringBuffer是同步的，数据安全性更高，效率较低；StringBuilder是不同步的，数据安全性更低，但是效率就比较高。
这里的安全都指的是在多线程的情况下，如果是在单线程的情况下，他们两个就几乎没有区别
StringBuffer和数组的区别
他们两个都可以看成是一个容器，但是区别的就是，StringBuffer就像一个大杂烩一样，放入的任何东西都最后转变成字符串， 但是，数组的话，就里面只能放多种数据但是必须是同一种数据。
形式参数问题
String作为参数传递
StringBuffer作为参数传递
形式参数：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
数组高级（排序和查找）
排序
冒泡排序
相邻元素两两比较，大的放在后面，等到一次结束以后，最大值就出现在了最后。
选择排序
从0索引开始，一次和后面的元素比较，小的往前放，第一次完毕，最小值出现在了，最小索引处。0位的和后面的依次比 较如果到4位，那就0位的到4位，4位上的就继续跟后面的5,6.，，，，进行比较，最后出现在第一位的就是最小的数字。
规则：
第一次是从0索引开始和其他的进行比较；
第二次是从1索引开始和其他进行比较；
最后一次是数组长度-2的元素和数组长度减一的比较
代码：
public static void main(String[] args) {
int[] arr = {2, 4, 1, 6, 3};
System.out.println("排序前的：");
for (int num:arr)
System.out.print(num);
System.out.println();
/*
//第一次
int x = 0;
for (int y = 1; y < arr.length;y++){
if (arr[y]<arr[x]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
System.out.println("第一次排序后的：");
for (int num:arr)
System.out.print(num);
System.out.println();
//第二次
x = 1;
for (int y = x+1; y < arr.length;y++){
if (arr[y]<arr[x]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
System.out.println("第二次排序后的：");
for (int num:arr)
System.out.print(num);
System.out.println();
//第三次
x = 2;
for (int y = x+1; y < arr.length;y++){
if (arr[y]<arr[x]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
System.out.println("第二次排序后的：");
for (int num:arr)
System.out.print(num);
System.out.println();
//第四次
x = 3;
for (int y = x+1; y < arr.length;y++){
if (arr[y]<arr[x]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
System.out.println("第二次排序后的：");
for (int num:arr)
System.out.print(num);
System.out.println();
*/
//通过代码发现，重复度很高
for (int x = 0; x < arr.length-1; x++){
for (int y = x+1; y < arr.length;y++){
if (arr[y]<arr[x]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
System.out.println("排序以后的：");
for (int num:arr)
System.out.print(num);
System.out.println();
}把字符串中的字符进行排序
dacgebf----------abcdefg
分析：
定义一个字符串，把字符串转化为字符数组，把字符数组进行排列，把排序后的字符数组转化为字符串，输出最后的字符 串。
代码：
public static void main(String[] args) {
//定义一个字符串
String s = "dacgebf";
System.out.println(s);
//把字符串转化成为字符数组
char[] chs = s.toCharArray();
//把字符数组进行排序
paiXu(chs);
//把字符转化成字符串
String result = String.valueOf(chs);
//打印
System.out.println("排序以后的：");
System.out.println(chs);
}
//冒泡排序
public static void paiXu(char[] chs) {
for (int x = 0; x < chs.length - 1; x++){
for (int y = 0 ;y < chs.length - 1 - x; y++){
if (chs[y] > chs[y + 1]){
char temp = chs[y];
chs[y] = chs[y + 1];
chs[y + 1] = temp;
}
}
}
}查找
基本查找 数组元素无序
从头找到尾
二分查找(折半查找法) 数组元素有序
每次都查找中间的那个数，然后比较大小，这样子每次都能减少一半的元素。
int min = 0; int mid = (min + max)/2; int max = arr.length - 1;
在第一次比较之后，如果要查找的数应该在左边，那么范围就应该是0------mid - 1；如果要查找的数应该在右 边，那么范围就应该是 mid + 1-------------arr.length - 1；后面就是类似的操作，把mid + 或 - 1命名为min或者，max
代码实现：
public static void main(String[] args) {
//定义一个数组
int[] arr = {1,2,3,4,5,6,7,8,9};
//写功能实现
//这里我们加入键盘输入
Scanner sc = new Scanner(System.in);
System.out.println("请输入想听要查找的数据：");
String s = sc.nextLine();
//要转变成int类型，因为Scanner获取的是用户输入的字符串
int i = new Integer(s);
int num = twoWayMethod(arr,i);
System.out.println(num);
}
public static int twoWayMethod(int[] arr, int value){
//定义最大值和最小值
int min = 0;
int max = arr.length - 1;
//计算出中间索引
int mid = (min + max)/2;
//那中间索引的值和要查找的数值进行比较,应该用while循环。他是最基本循环，如果返回值是true，就会一直循环。
while (arr[mid] != value){
if (arr[mid] > value){
max = mid - 1;
}else if (arr[mid] < value){
min = mid + 1;
}
mid = min + max;
}
return mid;
}Arrays类概述以及其常用方法
Arrays类概述
针对数组进行操作的工具类
提供了排序，查找等功能
成员方法（下面只是用int举例子，实质上它可以使用任何数组）
public static String toString(int[ ] a) ------------- 把数组转化成字符串
注意：以后只要对象，我们就要判断就是他是不是null
所以，以后在遍历数组时，可以System.out.println(Arrays.toString(arr)); ------------ 这样就可以转化为字符串然后就可 以输出到屏幕上。
public static void sort(int[ ] a) -------------对数组进行排序，也可以加入start和end，让中间的一部分元素进行排序
publix static int binarySearch(int[ ]a.int key) -------------这是二分查找的方法
有一个注意事项就是，这是二分查找的方法，所以要先进行排序，然后才能用这个方法
基本类型包装类概述
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数 据
为了对基本数据类型进行更多的操作，java就针对每一种基本数据类型提供了对应的类类型。包装类类型
常用的操作之一：用于基本数据类型和字符串之间的转换。
基本类型和包装类的对应
Byte,Short,integer,Long,Float,Double,Character,boolean
Integer类概述及其构造方法
Integer类概述
Integer类在对象中包装了一个基本类型int的值
该类提供了多个方法，能在int类型和String类型之间相互转化，还提供了提供处理int类型是非常有用的其他一些常量和方法
如果要用到Integer的话，这个字符串就必须是由数字字符组成才可以
直接把Integer转化成int的方法
int y = Integer.parseInt(s) -------- 要把一个数据类型a转化成另一个数据类型b，就找到b的包装类型的对应的方法。
构造方法
public Integer(int value)
public Integer(String s)
Integer类成员方法
常用的基本进制转换
public static String toBinaryString(int i)-------十进制到二进制
public static String toOctalString(int i)---------十进制到八进制
public static String toHexString(int i)-----------十进制到十六进制
十进制到其他进制
public static String toString(int i.int radix)---------int radix写的是你想转化到什么进制，如果是2，就是转为二进制，以此类推
由这个，我们也看到了进制的范围，是2------36。原因是0到9，a到z，加起来是36个
其他进制到十进制
public static int parseInt(String s.int radix)
这个和上面的十进制到其他进制是一样的
注意的一点就是，如果你要2进制到其他进制，那么你的数字就应该只有0和1组成
JDK5的新特性
JDK1.5以后，简化了定义方式
Integer x = new Integer(4)可以直接写成Integer x = 4;//自动装箱；
x= x + 5;//自动拆箱。通过intValue方法。
需要注意：
在使用时，Integer x = null;上面的代码就会出现NullPointerException。//空指针异常
自动装箱
把基本类型转化为包装类型
自动拆箱
把包装类型转化为基本类型
自动拆装箱的注意事项
自动拆装箱使用的前提是不能是null值。
所以，以后要经常打下面的代码：
if(x != null);这样子的话，就可以先判断是不是null，然后再进行后续。
Integer i1 = 2；
Integer i2 = 2;
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
在-128到127这个范围之内的数据，做了一个缓冲池。
在-128到127 之间不会创造一个新的空间，都是直接从缓冲池里获取数据返回到他们本身，但是在这个范围之外，就都是new出来的东西，属于一个新空间，所以第一个比较返回的就是错误的，第二个是直接比较的数值，所以就是正确的。
Character类概述及其构造方法
概述
Character类在对象中包装一个基本类型 char 的值
此外，该类提供了几种方法，已确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。
构造方法
public Character(char value)
功能
public static boolean isUpperCase(char ch)----------判断给定的字符是不是大写字符
public sratic boolean isLowerCase(char ch)----------判断给定的字符是不是小学字符
public static boolean isDigit(char ch)----------判断给定的字符是不是数字字符
public static char toUpperCase(char ch)----------把给定的字符转化为大写字符
public static char toLowerCase(char ch)----------把给定的字符转化为小写字符
代码实现：
/*
统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。（不考虑其它字符）
1，定义三个统计变量
int bigCont = 0;
int smallCont = 0;
int numberCont = 0;
2，键盘录入一个字符串
3，把字符串转化为字符数组
4，遍历该数组获取到每一个字符
5，判断该字符是
大写bigCont++;
小写smallCont++;
数字numberCont++;
6，输出结果即可
*/
public class Text3 {
public static void main(String[] args) {
//定义三个统计变量
int bigCont = 0;
int smallCont = 0;
int numberCont = 0;
//实现键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//把字符串转化为字符数组
char[] chs = line.toCharArray();
//遍历数组，得到每一个元素
for (char ch : chs) {
//判断该字符
if (Character.isUpperCase(ch)) {
bigCont += 1;
} else if (Character.isLowerCase(ch)) {
smallCont += 1;
} else if (Character.isDigit(ch)) {
numberCont += 1;
}
}
System.out.println("大写字母：" + bigCont + "个");
System.out.println("小写字母：" + smallCont + "个");
System.out.println("数字：" + numberCont + "个");
}正则表达式实现上述代码：
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的qq号：");
String qq = sc.nextLine();
System.out.println(checkQQ(qq));
}
public static boolean checkQQ(String qq){
String regex = "[1-9] [0-9] {4,14}";
//public boolean = qq.matches(String regex)告知此字符串是否匹配给定的正则表达式
boolean flag = qq.matches(regex);
return flag;
}正则表达式概述及基本使用
正则表达式：
简单来说，就是符合一定规则的字符串
是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。
其实就是一种规则 有自己特殊的应用。
举例
效验qq号码
1，必须是5---14位数字
2，0不能开头
正常代码实现：
/*
效验qq号码
要求：
1，必须是5-15位数字
2，0不能开头
分析：
1，键盘录入一个qq号码
2，写一个功能实现校验
3，调用功能，输出结果
*/
public class Text7 {
public static void main(String[] args) {
//创建键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的qq号码：");
String qq = sc.nextLine();
System.out.println(checkQQ(qq));
}
/*
写一个功能实现校验：
两个明确：
1，明确返回值类型：boolean
2，明确参数列表：String qq
*/
public static boolean checkQQ(String qq){
boolean flag ;
//首先校验长度
if (qq.length()>=5 && qq.length()<=15){
//0不能开头
if (!qq.startsWith("0")){
flag = true;
char[] chs = qq.toCharArray();
for (char ch : chs) {
if (Character.isDigit(ch)) {
flag = true;
} else {
flag = false;
break;
}
}
}else {
flag = false;
}
}else {
flag = false;
}
return flag;正则表达式的组成规则
规定字符在java.util.regex Pattern类中
常见组成规则：
字符：
x 字符 x。举例：'a'表示字符a。
\ \ 反斜线字符。
\n 换行符。
\r 回车符。
字符类：
[abc] a或b或c(简单类)。
[^abc] 任何字符，除了abc。
[a-zA-Z] a到z，或A到Z，两头的字母包括在内。
预定义字符类：
. 表示任何字符 如果我想要表示的就是.本身，如何表示？\.
\d 表示0-9。注意的一点就是，两个反斜杠才是一个
\D 表示的是非数字。
\w 单词字符：[a-zA-Z_0-9]
在正则表达式里面组成单词的东西必须有这些东西组成。
边界匹配器：
^ 行的开头
$ 行的结尾
\b 单词边界
就是不是单词字符的地方
只要不是单词字符，我们都把他叫做单词边界
数量词：
X? X 一次或一次也没有
X* X 零次或多次
X+ X 一次或多次
X{n} X 恰好n次
X{n,} X 至少n次
X{n,m} X至少n次，不超过m次
正则表达式的应用
判断功能
public boolean matches(String regex)
分割功能
public String[ ] split(String regex)
替换功能
public String replaceAll(String regex.String replacement)
获取功能
pattern和Matcher类的使用
正则表达式的练习
判断功能
效验邮箱
代码实现：
public static void main(String[] args) {
//键盘录入邮箱
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的邮箱：");
String email = sc.nextLine();
//定义邮箱的规则
String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}\\.[a-zA-Z_0-9]{2,3}";
boolean flag = email.matches(regex);
System.out.println(flag);
}分割功能
要求：
搜索：
性别：女
范围：“18-24”代码实现：
public static void main(String[] args) {
//定义一个年龄搜索范围
String ages = "18-24";
//定义规则
String regex = "-";
//调用方法
String[] strArray = ages.split(regex);
//遍历
// for (int x=0; x<strArray.length; x++){
// System.out.println(strArray[x]);
// }
//如何得到int类型的值呢
int startAge = Integer.parseInt(strArray[0]);
int endAge = Integer.parseInt(strArray[1]);
//键盘录入年龄
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的年龄：");
int age = sc.nextInt();
if (age>=startAge && age<=endAge){
System.out.println("你就是我想找的");
}else {
System.out.println("你不是我想找的");
}
}要注意的就是，在硬盘上的路径中的反斜杠，我们还是要打两个反斜杠来代表一个反斜杠
有如下字符串：“91 27 46 38 50”
请写代码让最终结果输出是：“27 38 46 50 91”
代码实现：
public static void main(String[] args) {
//输入一个字符串
String s = "91 27 46 38 50";
System.out.println("排序前："+s);
//利用正则表达式转化成数组
String[] strArray = s.split(" ");
//把上面的数组进行排列
Arrays.sort(strArray);
//打印结果
System.out.print("排序后：");
for (int x=0; x< strArray.length; x++){
System.out.print(strArray[x]+" ");
}
}在某一些需要相加的地方，还需要把String类型转化成int类型，否则就会出现1+1=11的情况，因为String是拼接的，只有在int的情况下才能是1+1=2
替换功能
论坛中不能出现数字字符，用*替换
代码:
public static void main(String[] args) {
//使用键盘录入原字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符：");
String str = sc.nextLine();
//使用正则表达式之前的准备
String s = str;
String s1 = "*";
//使用正则表达式
String str1 = s.replaceAll("[0-9]",s1);
//打印结果
System.out.println(str1);
}获取数据
获取由三个字符组成的单词
代码实现：
public static void main(String[] args) {
//定义字符串
String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";
//规则
//注意：这里要使用到单词边界
String regex = "\\b\\w{3}\\b";
//把规则编译成模式对象
Pattern p = Pattern.compile(regex);
//通过模式对象得到匹配器对象
Matcher m = p.matcher(s);
//调用匹配器对象的功能
//通过find方法就是查找有没有满足条件的子串
//public boolean find()
// boolean flag = m.find();
//通过group就可以返回刚才相匹配的值
//public String group
// String s1 = m.group();
// System.out.println(s1);
while (m.find()){
System.out.print(m.group()+" ");////注意：要先find，再group，因为应该先进行匹配操作，才能在下面返回匹配 到的值
}
}Math类概述及其成员方法
Math类概述
Math类包含用于执行基本数学运算的方法，如初等指数，对数，平方根和三角函数。
都是静态的，不用创建对象
成员方法
public static int abs(int a)----------返回绝对值
public static double ceil(double a)----------向上取整
public static double floor(double a)----------向下取整
public static int max(int a，int b)//同理min----------返回最大值（最小值）
public static double pow(double a，double b)----------返回a的b次幂
public static double random()----------随机数
public static int round(float a)//参数为double的自学----------四舍五入
public static double sqrt(double a)----------返回正平方根
代码实现：
public static void main(String[] args) {
//public sratic final double PI
System.out.println("PI:"+Math.PI);
//public static final double E
System.out.println("E:"+Math.E);
//public static int abs(int a)绝对值
System.out.println("abs:"+Math.abs(10));
System.out.println("abs:"+Math.abs(-10));
//public static double ceil(double a)向上取整
System.out.println("向上取整："+Math.ceil(519.123));
//public static double floor(double a)向下取整
System.out.println("向下取整："+Math.floor(520.123));
//public static int max(int a,int b)//同理min 返回最大值
System.out.println("最大值："+Math.max(520,521));
//这个方式是可以嵌套使用的
System.out.println("最大值："+Math.max(Math.max(1,2),3));
//public static double pow(double a.double b)返回a的b次幂
System.out.println("a的b次幂："+Math.pow(12,3));
//public static double random() 随机数
System.out.println("随机数："+Math.random());
//获取一个1到100，之间的随机数
System.out.println("1-100之间的随机数："+((int)(Math.random()*100)+1));
//public static int round(float a)//参数为double的自学 四舍五入
System.out.println("四舍五入："+Math.round(12.231));
//public static double sqrt(double a) 返回正平方根
System.out.println("返回正平方根："+Math.sqrt(4));
}Random类概述及其构造方法
Random类概述
此类用于产生随机数
如果用相同的种子创建两个Random实例，则对每个实例进行相同的方法调用序列，他们将生成并返回相同的数字序列。
如果制定了种子，就会返回相同的随机数
Random类构造方法
主要是要了解，这两种方法给不给种子的区别
方法一：Random( )----------创建一个新的随机数生成器
方法二：Random(long seed)----------使用单个long种子创建一个新的随机数生成器
Random的成员方法
public int nextInt();----------返回一个伪随机数，他是随机数生成器的序列中均匀分布的int值
public int nextInt(int n);----------返回一个伪随机数，他是取自此随机数生成器的序列的，在0（包括）和指定值（不包括）之间均匀分布的int值
代码实现：
public static void main(String[] args) {
//使用默认种子的构造
Random r = new Random();
System.out.println("使用默认种子的随机数：");
int num = r.nextInt();
//返回int范围内的随机数
System.out.println(num);
int num1 = r.nextInt(100);
//返回[0,int)内的随机数
System.out.println(num1);
//使用指定种子的构造
Random r1 = new Random(1);
System.out.println("使用指定种子的随机数：");
int num3 = r1.nextInt();
System.out.println(num3);
int num4 = r1.nextInt(100);
System.out.println(num4);
}System类概述及其成员方法
System类概述
System包含一些有用的类字段和方法，他不能被实例化。
成员方法
public static void gc()----------运行垃圾回收器
public static void exit(int status)----------终止当前正在运行的java虚拟机；根据惯例，非0状态码表示异常终止。
public static long currentTimeMillis()----------返回以毫秒为单位的当前时间，当返回值是毫秒时，值的粒度取决于底层操作系统，并且粒度可能更大。比如，很多操作系统以几十毫秒为单位测量时间
返回当前时间与协调世界时 1970年1月1日午夜之间的时间差（以毫秒为单位测量）
作用，给前后计时，在程序前面int start，在程序后int end 这样操作以后，程序的运行时间就是end-start
public static void arrycopy(Object src.intstcPos.Objext.int destPos.int length)
参数的意义：
src-源数组
srcPos-源数组中的起始位置
dest-目标数组
desPos-目标数组中的起始位置
length-要复制的数组元素的数量
这个的写法是错误的：c没有大写，这里要注意
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
代码实现：
public static void main(String[] args) {
//计算开始时的时间
long start = System.currentTimeMillis();
System.out.println("陕西");
//计算结束后的时间
long end = System.currentTimeMillis();
//这就是上面程序的运行时间
System.out.println(end-start);
//终止正在运行的虚拟机
//就相当于是在运行完上面的打印以后就不在运行
System.exit(0);
System.out.println("西安");
}BigInteger类概述及其构造方法
BigInteger类概述
可以让超过Integer范围内的数据进行运算
构造方法
public BigInteger(String val)
代码实现：
public static void main(String[] args) {
//这几个测试是为了测试，超过int范围内，Integer就不能在表示，所以就更谈不上计算了。
Integer i = new Integer(100);
System.out.println(i);
//System.out.println(Integer.MAX_VALUE);
//上面的这个代码可以找到这个范围的最大范围
//下面的代码就是int可以正常显示的最大值
Integer ii = new Integer("2147483647");
System.out.println(ii);
//下面的代码就是超出范围以后的
//Integer iii = new Integer("2147483648");
//System.out.println(iii);
//下面通过上面的大整型的构造方法来创建对象
BigInteger bi = new BigInteger("147483648");
System.out.println(bi);
}BigInteger类成员方法
public BigInteger add(BigInteger val)----------加法运算
public BigInteger subtract(BigInteger val)----------减法运算
public BigInteger multiply(BigInteger val)----------乘法运算
public BigInteger divide(BigInteger val)----------除法运算
public BigInteger[] divideAndRemainder(BigInteger val)----------返回商和余数的数组
代码实现：
public static void main(String[] args) {
BigInteger bi = new BigInteger("100");
BigInteger bi2 = new BigInteger("50");
//加分运算
System.out.println("相加的结果："+bi.add(bi2));
//减法运算
System.out.println("相减的结果："+bi.subtract(bi2));//用前面的减去后面的
//乘法运算
System.out.println("相乘的结果："+bi.multiply(bi2));
//除法运算
System.out.println("除法以后的结果："+bi.divide(bi2));
//返回商和余数的数组
BigInteger[] arr = bi.divideAndRemainder(bi2);
System.out.println("相除的商："+arr[0]);
System.out.println("相除所得的余数："+arr[1]);
}BigDecimal类概述及其构造方法
作用
由于在运算的时候，float类型和double类型很容易丢失精度，演示案例。所以为了能精确的表示，计算浮点数，java提供了BigRecimal
概述
不可变的，任意精度的有符号十进制数
构造方法
public BigDecimal(String val)
虽然有其他的构造方法，但是，其他的构造方法也是有着一定的不可预知性，所以上面的这个构造方法就是最稳妥的办法
成员方法
public BigDecimal add(BigDecimal augend)----------加法运算
public BigDecimal subtract(BigDecimal subtrahend)----------减法运算
public BigDecimal multiply(BigDecimal multiplicand)----------乘法运算
public BigDecimal divide(BigDecimal divisor)----------除法运算
public BigDecimal divide(BigDecimal divisor.int scale,int roundMode)----------商，几位小数，如何舍取，通俗理解就是来取有效数字，最后的参数是舍入模式,详情在jdk自己查。
注意事项
这个方法使用的方式一定是两个对象之间，建议：在一些情况下，使用匿名对象调用法
代码实现
public static void main(String[] args) {
BigDecimal bd1 = new BigDecimal("0.09");
BigDecimal bd2 = new BigDecimal("0.01");
System.out.println("相加的结果："+bd1.add(bd2));
System.out.println("减法运算结果："+bd1.subtract(bd2));
System.out.println("乘法运算结果："+bd1.multiply(bd2));
System.out.println("除法运算结果："+bd1.divide(bd2));
System.out.println("除法运算结果（保留三位有效数字）："+bd1.divide(bd2,3,BigDecimal.ROUND_DOWN));
}Date类概述及其方法
Date类概述
类Date表示特定的瞬间，精确到毫秒。这个类大部分都已经过时，但是由于有的地方还在使用过这个类，所以我们需要去了解，在下面会有另一个类来更好的替代他。。
构造方法
public Date（）；----------无参构造，根据当前的毫秒值来创建日期对象
public Date（long date）；----------有参构造，根据给定的毫秒值来创建日期对象
成员方法
public long getTime（）；----------获取时间，以毫秒值为单位
public void SetTime（long time）；----------设置时间
该类的学习要求
可以从Date中获取毫秒值
可以把毫秒值转化成Date----------这个有两种方法，一种就是在有参构造的时候就可以带入参数，还有一种就是创建对象，然后使用setDate来设置时间
代码实现
public static void main(String[] args) {
//无参构造
Date date = new Date();
System.out.println("无参构造显示date:"+date);
//有参构造
Date date1 = new Date(1000 * 60 * 60);//1小时
System.out.println("有参构造选择date："+date1);//显示的是9个小时，原因是中国是东八区，所以就要加个8.
//该类的方法
System.out.println("当前的时间："+new Date().getTime());
}DateFormatDemo类概述及其方法
DateFormatDemo类的概述
可以进行日期的格式化以及解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat
它是日期时间格式化子类的抽象类，它以与语言无关的方式并解析日期或者时间。
是抽象类，所以使用其子类SimpleDateFormat（就是格式化，即从日期转到文本）解析就是从文本到日期
SimpleDateFormat构造方法
public SimpleDateFormat（）；----------这个就是默认的模式显示格式化以后的文本
public SimpleDateFormat（String pattern）；----------这个就是给定模式来显示格式化之后的文本
里面模式的字符串怎么写：
前面的第一列字符就是表示方法，
这里面比较常用的就是：年：y； 月：M； 日：d； 时：H； 分：m； 秒：s；
2002年11月06日 11:11:11
yyyy年MM月dd日HH小时mm分钟ss秒成员方法
public final String format（Date date）；----------可以把日期格式化成文本格式
public Date parse（String source）；-----------可以把文本解析为日期
注意：
在解析的过程中，应该注意给定格式的字符串的格式，应该与输入的格式相同
代码实现
public static void main(String[] args) {
//创建日期对象
Date date = new Date();
//创建格式化对象
SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
//我们需要的方法就是，接收上面的日期，然后就可以转化成文本的格式
String s = simpleDateFormat.format(date);
System.out.println("格式化成文本以后的显示效果："+s);
//现在来试试给定模式的格式化
//2002年11月06日 11:11:11
//yyyy年MM月dd日HH小时mm分钟ss秒
//创建给定模式的格式化对象
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日HH小时mm分钟ss秒");
//接收上面的日期，使用给定格式转化成文本
String s1 = simpleDateFormat1.format(date);
System.out.println("使用给定模式之后格式化成文本的显示效果："+s1);
//给定一个字符串，把它解析成日期
String s2 = "2002-11-06 11:11:11";
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
Date date1 = simpleDateFormat2.parse(s2);
System.out.println(date1);
} catch (ParseException e) {
e.printStackTrace();
}
}抽象类
什么是抽象类
若一个类中没有包含足够的信息描绘一个具体的对象，则称这个类为抽象类
要点及注意事项
1，抽象类不能实例化对象，因此抽象类必须被子类继承。而且，子类实例化的对象必须调用所继承的抽象类中等方法。
2，抽象类中定义的抽象方法后面没有方法体急没有给出方法的具体实现，直接以；结束即可。
3，抽象类中不一定有抽象方法，但是抽象方法一定是抽象类。
4，用static关键字修饰的类方法和构造方法是不能定义为抽象方法的。
5，如果一个子类不是抽象类且要继承一个抽象类，则这个子类必须继承的抽象类中定义的抽象方法。
注意事项
1，构造方法不能被声明为抽象方法
2，抽象类不能实例化对象，通俗来讲就是，用抽象类不能new一个对象
Date类及DateFormat类练习
制作一个工具类。DateUtil
代码实现
public DateUtil() {
}
//从Date类型格式化成字符串类型
//传入了Date数据还有想要格式化成的格式，方便以后直接传入数据
/**
*
* @param date 被转换的日期对象
* @param format 传递过来的日期格式
* @return 返回格式化的字符串
*/
public static String dateToString(Date date, String format) {
// SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
// return simpleDateFormat.format(date);
return new SimpleDateFormat(format).format(date);
}
//从String解析成Date
/**
*这个方法的作用就是把一个字符串转化成一个日期对象
* @param s 想要转化成Date类型的字符串
* @param format 想要转化的格式
* @return 返回的Date类型
* @throws ParseException
*/
public static Date stringToDate(String s, String format) throws ParseException {
return new SimpleDateFormat(format).parse(s);
} public static void main(String[] args) throws ParseException {
Date date = new Date();
//yy-MM-dd HH:mm:ss
String s = DateUtil.dateToString(date, "yy-MM-dd HH:mm:ss");
System.out.println(s);
String s1 = "2002-11-06";
Date date1 = DateUtil.stringToDate(s1, "yy-MM-dd HH:mm:ss");
System.out.println(date1);
}计算一下你来到这个世界多少天
代码实现
//正常的方法应该把年月日分开来键盘录入
//然后使用StringBuffer进行字符拼接
public static void main(String[] args) throws ParseException {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的出生年月日：");
String s = scanner.nextLine();
//把该字符串转换为一个日期
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = simpleDateFormat.parse(s);
//通过该日期得到一个毫秒值
long time = date.getTime();
//获取当前日期的毫秒值
long time1 = System.currentTimeMillis();
//用当前的毫秒值减去出生年月日获取的毫秒值
long time2 = time1 - time;
//把上一个毫秒值转化成天数
long days = time2/1000/60/60/24;
//输出日期
System.out.println(days+"天");
}Calendar类概述及其方法
calendar类概述
calendar是一个抽象类，他为特定瞬间与一组诸如TEAR，MONTH，DAY_OF_MONTH，HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法
该类（日历类）中的每一个日历字段都是静态的成员变量，并且是int类型
成员方法
public static Calendar getInstance();----------获取当前的时间
public int get(int field);----------返回给定日历字段的值
public void add(int field, int amount);----------根据给定的日历字段和时间，对选中的日历字段进行操作
public final void set(int year, int month, int date);----------进行日历时间的设定，设置年月日
注意事项
其他的日历字段都是直接获取，但是，在获取月份时，要加个一，因为月份的计算方法是从0-11的
代码实现
public static void main(String[] args) {
//其日历字段已由当前日期和时间初始化、
Calendar calendar = Calendar.getInstance();//虽然Calender是一个虚拟类，不能实例化对象，但是等号后面其实是子类对象，相当于是个等量代换
//获取年
int year = calendar.get(Calendar.YEAR);
//获取月份
int month = calendar.get(Calendar.MONTH);
//获取日期
int days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+(month+1)+"月"+days+"日");
//三年前的今天
calendar.add(Calendar.YEAR, -3);
//获取年
year = calendar.get(Calendar.YEAR);
//获取月份
month = calendar.get(Calendar.MONTH);
//获取日期
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+(month+1)+"月"+days+"日");
//5年后的10天前
calendar.add(Calendar.YEAR, 5);
calendar.add(Calendar.DAY_OF_MONTH, -10);
//获取年
year = calendar.get(Calendar.YEAR);
//获取月份
month = calendar.get(Calendar.MONTH);
//获取日期
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+(month+1)+"月"+days+"日");
}获取任意一年的二月份有多少天代码实现
思路
获取任意一年的二月份有多少天
分析：
1，键盘录入任意的年份
2，设置日历对象的年月日
年就是1中输入的数据
月就是2
日就是1
3，把时间往前推一天，就是二月的最后一天
4，最后输出日期代码实现
public static void main(String[] args) {
//没有学Calender之前，我们的想法是，先判断是否是闰年，再进行判断
//键盘录入我们的年份
Scanner scanner = new Scanner(System.in);
System.out.println("请输入年份：");
int year = scanner.nextInt();
//设置该日历对象的年月日
//先造一个对象
Calendar calendar = Calendar.getInstance();
calendar.set(year, 2, 1);//其实是三月一日
//接着往前推一天
calendar.add(Calendar.DATE, -1);
//然后获取这一天，输出
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
}数组练习题
要求
我有五个学生，请把这五个学生的信息储存到数组中，并遍历数组，获取到每一个学生的信息
分析
1，创建学生类
2，创建学生数组
3，创建五个学生对象，并赋值
4，把3里面的元素放到数组中
5，遍历学生数组
集合
集合类概述
为什么会出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，java就提供了集合类。
我们想要存储对象，就不能是一个基本的变量，而是一个容器类型的变量，我们在目前所学过的知识里面，
有哪些是容器类型的呢？数组和StringBuffer，但是后者的结果是一个字符串，不一定满足我们的要求，
所以我们只能选择数组，这就是对象数组，而对象数组又不能适应变化的需求，这个时候为了适应变化的需求，
这个时候，java就提供了集合类
数组和集合都是容器，有什么不同？
数组也可以存储对象，但长度是固定的。集合长度是可变的。数组中可以储存基本数据类型，集合只能储存对象
一个是长度问题：数组长度固定，但是集合不固定
内容：数组存的是同一种类型，集合可以存储不同类型
元素的数据类型：数组可以存基本类型，也可以存引用类型，但是集合只能存引用类型
集合类的特点
集合只用于储存对象，集合长度是可变的，集合可以储存不同类型的对象。
集合是储存多个元素的，但是，储存多个元素我们也是有要求的：比如说，不能有相同的，不如说，我要这多个元素按照某种规则，所以，针对不同的需求，java就提供了不同的集合类，这多个集合类的数据结构不同。
但是，结构不同不重要，重要的是要能够储存东西，并且还要可以使用这些东西
既然这样，那么，这多个集合类是有共性的内容的，我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系。
数据结构
数据的存储方式
Collection类接口概述
概述
Collection层次结构中的根接口。Collection类表示一组对象，这些对象也称为Collection的元素。一些Collection允许有重复的元素，而另一些则不允许，一些Collection是有序的，还有一些Collection是无序的。
功能概述
1，添加功能
boolean add（E e）----------添加一个元素
boolean addAll（collection<? extends E> c）----------添加一个集合的元素,再添加一个集合的元素时，如果两个集合有相同的元素，也会继续添加
2，删除功能
void clear()----------移除所有元素
boolean remove（Object o）----------移除一个元素，他返回的是boolean，如果集合中有要删除的东西，那就会成功删除，返回true，如果没有的话，那就是返回
boolean removeAll（Collection c）----------移除一个集合的元素,在移除时，如果上一个集合有两个一样的下一个集合的元素，都会被移除
3，判断功能
boolean contains（object o）----------判断集合中是否包含指定的元素
boolean containsAll（Collection<?> c）----------判断集合中是否包含指定的集合元素，这里要全部包含才能返回true
boolean isEmpty( )----------判断集合是否为空（这里的空是指数据的元素为空），这里的判断如果有元素就是false，没有元素就是true。
4，获取功能
Iterator<E> iterator( ) ----------重点
5，长度功能
int size（）----------元素的个数
面试题：
数组有没有length（）方法？字符串有没有length（）方法？集合有没有length（）方法？
答：数组没有，数组的那个不叫方法，叫做数组的属性；字符串有length方法；集合没有length（）方法，集合的方法名字叫size（）
6，交集功能
boolean retainAll（Collection<?> c）----------两个集合都有的元素，思考元素去哪了，返回的boolean又是什么意思呢？
7，把集合转化成数组
Object[ ] toArray( )----------把集合转化为数组
8，代码实现
1，不带all的测试
public class Text32 {
public static void main(String[] args) {
//测试不带All的方法
//创建集合对象
// Collection c = new Collection();//这是不对的，因为接口不能实例化，所以我们要找它的实现类
Collection collection = new ArrayList();
//boolean add(Object obj)-----添加一个元素
collection.add("Hello");
collection.add("Word");
collection.add("Java");
// //void clear()----------移除所有元素；因为是void所以不需要接收
// collection.clear();
//boolean remove（Object o）----------移除一个元素
collection.remove("Hello");
//补齐元素
collection.add("Hello");
//boolean contains(Odject o)-----判断集合中是否包含指定的元素
System.out.println("集合中是否包含这个元素：" + collection.contains("Java"));
System.out.println("集合中是否包含这个元素：" + collection.contains("lxl"));
//判断集合是否为空
System.out.println("集合是否为空：" + collection.isEmpty());
//int size（）----------元素的个数
System.out.println("元素的个数：" + collection.size());
//显示集合
System.out.println("c" + collection);
}
}2，带All的代码实现
public static void main(String[] args) {
//创建集合1
Collection collection = new ArrayList();
collection.add("a");
collection.add("b");
collection.add("c");
//创建集合2
Collection collection1 = new ArrayList();
collection1.add("a");
collection1.add("b1");
collection1.add("c2");
//boolean addAll（collection<? extends E> c）----------添加一个集合的元素
collection.addAll(collection1);//再添加一个集合的元素时，如果两个集合有相同的元素，也会继续添加
//boolean removeAll（Collection c）----------移除一个集合的元素
collection.removeAll(collection1);//在移除时，如果上一个集合有两个一样的下一个集合的元素，都会被移除
//boolean containsAll Collection<?> c）----------判断集合中是否包含指定的集合元素
System.out.println("集合1中是否包含集合2的元素：" + collection.containsAll(collection1));//需要全部包含才能返回true
//对集合一补充元素,这样两个集合中就有相同的元素
collection.add("a");
//boolean retainAll（Collection<?> c）----------两个集合都有的元素，思考元素去哪了，返回的boolean又是什么意思呢？
//假设有两个集合A，B
//A对B做交集，最终的结果保存在A里面，B不变，返回值表示的是A是否发生过改变
collection.retainAll(collection1);//谁调用这个方法，元素就被谁保存
//显示两个集合
System.out.println("显示集合1：" + collection);
System.out.println("显示集合2：" + collection1);
}3，集合的遍历代码实现
public static void main(String[] args) {
//创建集合对象
Collection collection = new ArrayList();
//添加元素
collection.add("a");
collection.add("b");
collection.add("c");
collection.add("d");
//遍历
//Object[ ] toArray( )----------把集合转化为数组，可实现集合的遍历
Object[] objects = collection.toArray();
System.out.println("数组的遍历：");
for (int i=0; i<objects.length; i++) {
//System.out.print(objects[i]+" ");
//我知道元素是字符串，我在获取元素的同时，还想知道元素的长度
//上面的实现不了，因为Object，Object这种没有length的方法
//我们想使用字符串的方法，就必须把元素还原成字符串
//向下转型
String string = (String) objects[i];
System.out.println(string + " " + "该元素的长度为：" + string.length());
}
}4，练习
用集合存储5个学生对象，并把学生对象进行遍历
分析：
1，创建学生类
2，创建集合对象
3，创建学生对象
4，把学生添加到集合
5，把集合转化成数组
6，遍历数组
代码实现：
public static void main(String[] args) {
//创建集合对象
Collection collection = new ArrayList();
//创建学生对象
Text35_student s1 = new Text35_student("a", 1);
Text35_student s2 = new Text35_student("b", 2);
Text35_student s3 = new Text35_student("c", 3);
Text35_student s4 = new Text35_student("d", 4);
Text35_student s5 = new Text35_student("e", 5);
//把学生添加到集合
collection.add(s1);
collection.add(s2);
collection.add(s3);
collection.add(s4);
collection.add(s5);
//把集合转成数组
Object[] object = collection.toArray();
//遍历数组
for (int i = 0; i < object.length; i++) {
System.out.println(object[i]);//这样子打出来是一串地址值
}
for (int i = 0; i < object.length; i++) {
//向上转型
Text35_student text35_student = (Text35_student)object[i];
System.out.println(text35_student.getStudentName() + " " + text35_student.getStudentAge());
}
}创建上面方法的学生类
//创建学生类
public String studentName;
public int studentAge;
//构造方 法
public Text35_student(String studentName, int studentAge) {
this.studentName = studentName;
this.studentAge = studentAge;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public int getStudentAge() {
return studentAge;
}
public void setStudentAge(int studentAge) {
this.studentAge = studentAge;
}9，Iterator iterator( )-----迭代器，集合的专用遍历方式
一个方法的返回值是接口，那么肯定返回的是子类的对象。
方法：
E(odject) next()-----获取元素,并移动到下一个位置。、
has Next()-----判断是否可以继续进行迭代，并返回bollean值
代码实现：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* Iterator iterator()-----迭代器，集合的专用遍历方式
*
* E(odject) next()-----获取元素,并移动到下一个位置
*
* has Next()-----判断是否可以继续进行迭代，并返回bollean值
*
* NoSuchElementException-----没有这样的元素异常，因为你已经找到最后了
*/
public class Text36 {
public static void main(String[] args) {
//创建集合对象
Collection collection = new ArrayList();
//添加元素
collection.add("Hello");
collection.add("Word");
collection.add("java");
//Iterator iterator()-----迭代器，集合的专用遍历方式
Iterator iterator = collection.iterator();//Iterator是一个接口，所以，实际返回的是子类对象，这里是多态
// Object object = iterator.next();
// System.out.println(object);
//
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
//最后一个不应该写，所以，我们应该在每一次获取前，都需要有一个判断
//判断是否有下一个元素，如果有就获取，如果没有的话，就结束
// if (iterator.hasNext()) {
// System.out.println(iterator.next());
// }
//
// if (iterator.hasNext()) {
// System.out.println(iterator.next());
// }
//
// if (iterator.hasNext()) {
// System.out.println(iterator.next());
// }
//上面的格式一样，直接使用while循环
while (iterator.hasNext()) {
// System.out.println(iterator.next());
String s = (String)iterator.next();
System.out.println(s);
}
}
}练习：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* 练习：练习集合中迭代器的使用
* 用集合储存5个学生对象，并把学生对象进行遍历。用迭代器遍历。
*
* 注意：
* 自己写的类名不能和API中的类名相同-----不会报错，但是强烈不建议使用
* 复制代码的时候，很容易把那个类所在的包也导进去，容易出现不能理解的问题
*/
public class Text37 {
public static void main(String[] args) {
//创建集合对象
Collection collection = new ArrayList();
//创建学生对象
Text35_student s1 = new Text35_student("a", 1);
Text35_student s2 = new Text35_student("b", 2);
Text35_student s3 = new Text35_student("c", 3);
Text35_student s4 = new Text35_student("d", 4);
Text35_student s5 = new Text35_student("e", 5);
//把学生添加到集合中
collection.add(s1);
collection.add(s2);
collection.add(s3);
collection.add(s4);
collection.add(s5);
//遍历
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
// System.out.println(iterator.next());//我们在学生类里面已经写过一个toString方法，所以这里打出来的是字符串，否则打出来的是一个地址值。
Text35_student s = (Text35_student) iterator.next();
System.out.println(s);
}
}
}Iterator接口的使用和原理讲解
迭代器：
是遍历集合的一种方式。
迭代器是依赖于集合而存在的。必须先有集合，然后有迭代器
Iterator接口的使用讲解
集合的使用步骤：
创建集合对象
创建元素对象
把元素添加到集合
通过集合获取迭代器对象
遍历集合
1，通过集合对象获取迭代器对象
2，通过迭代器的hasNext的方法来确定是否有元素
3,通过迭代器对象的next方法获取元素并移动到下一个位置
Iterator接口的原理讲解
为什么不定义成一个类，而是一个接口
假设迭代器定义的是一个类，这样我们就可以创建该类的对象，调用这些类的方法来实现集合的遍历。但是呢？java中提供了很多类，这些集合类的诗句结构是不同的，所以储存的方式是不一样的，进而他们的遍历方式应该也是不一样的。最终，就没有定义迭代器类。
而无论你是哪种集合（集合有很多种，常见的集合是Array），你都应该具备获取元素的操作，并且，最好再辅助于判断功能，这样，在获取前，先进行判断。也就是说，判断功能和获取功能应该是遍历中应该具备的。每种集合的方式又不太一样，所以我们把这两个功能给提取出来，但是并不提供具体实现，这种方式就是接口。
那么，真正的具体的实现类在哪里呢？
在真正的具体的子类中，以内部类的方式体现的。
看源码是如何实现的
public interface Inteator {
public abstract boolean hasNext();
public abstract Object next();
}
public interface Iterable {
Iterator iterator();
}
//这是一个接口，在他之前还有一个接口
public interface Collection extends Iterable {
在这里面只是进行了定义，没有具体的实现
}
public interface List extends Collection {
在这里面也没有具体实现
}
//在这里面进行了实现
public class ArrayList implements List {
public Iterator iterator() {
return new Itr();
//Itr();一定是接口的实现类
}
//是一个私有类，外界不知道它的实现方式
private class Itr implements Iterator
{
}
}注意事项
注意： 自己写的类名不能和API中的类名相同-----不会报错，但是强烈不建议使用 复制代码的时候，很容易把那个类所在的包也导进去，容易出现不能理解的问题 不要多次使用next，因为他还会进行迭代 思考： 能用while循环写这个程序，那能不能使用for循环来写呢 while的格式更加清楚，但是for循环的好处就是他的效率就更高
List接口概述
List接口概述
有序的Collection（也称序列）。此接口的用户可以对列表中的每一个元素的插入位置进行精确的控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
与Set不同，列表通常允许重复的元素。
List案例
储存字符串并遍历
public class Text38 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//存储元素
list.add("Hello");
list.add("Word");
list.add("Java");//添加了两个相同的元素，以用来证明，元素是可重复的
list.add("Javaee");
list.add("Android");
list.add("Java");
//开始验证它的有序性，如果读取的元素的顺序和它存储进去的元素的顺序是一样的，那就可以证明，它的有序性就是指，出去的元素和放入元素的顺序一样。
//遍历集合
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String s = (String)iterator.next();
System.out.println(s);
}
}
}储存自定义对象并遍历
package com.shiyan;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Text39 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//创建学生对象
Text35_student s1 = new Text35_student("a",1);
Text35_student s2 = new Text35_student("b",2);
Text35_student s3 = new Text35_student("c",3);
//把学生对象添加到集合对象中
list.add(s1);
list.add(s2);
list.add(s3);
//遍历
//得到迭代器
Iterator iterator = list.iterator();
//通过while进行循环得到数组
while (iterator.hasNext()) {
//把集合里面的元素进行强制换型
Text35_student s = (Text35_student) iterator.next();
//输出
System.out.println(s.getStudentName()+"-------"+s.getStudentAge());
}
}
}List和Collection的区别
List list = new ArrayList（）；有序的Collection，这里的有序是指，我输入123546，我输入是什么顺序，输出就是什么顺序。
可以对列表中的每一个元素的插入位置进行精确的控制。说明是有索引的，用户可以根据元素的索引访问元素，并搜索列表中的元素吗，与set不同，列表通常允许重复的元素，也就是说，List中的元素时可重复的，List下的ArrayList，Vector，LinkedList也是可以重复的
List集合的特有功能
添加功能
void add（int index，Object element）-----在指定位置添加一个元素
如果前面的索引是1的话，那就是在第一位元素的后面添加新的元素，如果前面的索引输入超过范围，运行时报错（索引越界）。
获取功能
Object get（int index）-----获取指定位置的元素
这个获取的元素是索引后面那个元素，就比如abcd4个元素，当我输入索引1，得到的元素就是 b。也会出现越界的报错
列表迭代器
（这是List集合特有的迭代器）-----ListIterator listIterator（）
删除功能
Object remove（int index）-----根据索引删除元素，返回被删除的元素
也会出现角标越界的情况
修改功能
Object set（int index，Object element）-----根据索引修改元素，返回被修改的元素
遍历方式
可以使用Size和Get的方法结合起来进行最终的遍历方法
代码实现：
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//用以前的方法来添加元素
list.add("Hello");
list.add("Word");
list.add("JavaSE");
System.out.println("List:" + list);
System.out.println("----------------------------------------------------------");
//在指定位置添加元素
list.add(1,"Android");
System.out.println("List:" + list);
System.out.println("----------------------------------------------------------");
//获取指定位置的元素
System.out.println("Get:" + list.get(1));
System.out.println("----------------------------------------------------------");
//根据索引来删除元素,返回被删除的元素
System.out.println("Remove:" + list.remove(1));
System.out.println("List:" + list);
System.out.println("----------------------------------------------------------");
//修改功能，根据索引修改元素，返回被修改的元素
System.out.println("Set:" + list.set(1,"Android"));//可以看到被修改的元素是Word
System.out.println("List:" + list);
System.out.println("----------------------------------------------------------");
//使用Size和Get方法结合，并使用for遍历
System.out.print("List:");
for (int i =0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
}idea的快捷使用方法
如何快速的get set方法
光标点击到私有成员变量上
然后使用Alt + Insert键，在里面选择get and set，之后选择你想要让哪些变量实现这个方法，最后点击ok
如何查找这一个类中的所有方法
使用Alt + 7。可以查看类的字段，属性，方法，是否继承
This关键字
概述
This关键字代表了当前的对象，或者代表将来创建好的对象
this是一个引用类型
This的使用场合
1，可以在普通方法中使用
重写和重载的区别
重写
重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。这就是说"外壳不变，核心重写"
重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说，子类能够根据需要实现父类的方法。
重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。
重载
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
接口和虚拟类的区别
ListIterator接口的成员方法
概述
是List特有的迭代器，叫做列表迭代器
该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext（）和next（）方法。
boolean hasPrevious()
如果以逆向遍历列表，列表迭代器有多个元素，则返回true（换句话说，如果Previous返回的是一个元素而不是抛出异常，则返回true）
Object previous()
返回列表的前一个元素。可以重复使用此方法来迭代列表，或混合调用next来前后移动（注意交替使用next和Previous将返回相同的元素）
返回：列表中的上一个元素
抛出：NoSuchElementException--如果没有可迭代的上一个元素
//问题：22
// 我有一个集合如下，请问，我想判断里面有没有“word”这个元素，如果
//有，我就添加一个“javaee”元素，请写代码实现
ConcurrentModifcationException
现象
原因
解决方案
