1、Java语言语法规则和文件格式；
第一个Java程序：
/**
第一个Java程序：
控制台输出Hello world！
*/
public class Test{
//访问修饰符 class关键词用于声明类使用 后面跟类名
public static void main(String args[]){//程序的入口，主函数main方法；
System.out.println(“Hello world!”);// 输出语句
}
}
Java语言区分大小写；
public 为访问修饰符；
class关键词，用于声明类；
/**/ 多行注释；注释掉内容不被程序视为可执行内容；
//单行注释；
一条语句结束，需要通过“;” 分号结束，表示这条语句已经结束；
Java语言可以通过空格或者换行符、制表符等将其分隔开.
文件格式：一个Java程序，需要有类的声明，一般一个.java 文件中只有一个类；但是，也可以有多个class存在，此时主意：一个.java文件中，只能存在一个public 修饰的类，即：一个java文件名，应该与这个文件中public 修饰的类名相同；一个java文件中只能存在一个public 修饰的类；
2、程序的入口主函数（主方法）；
在java中主函数main方法，语句格式如下：public static void main(String args[]){}
主函数只能存在于public修饰的类中；否则无法执行该主方法；如果放到其他没有被public修饰的类中，没语法错误，但是无法执行。
3、变量的声明和赋值；
变量主要用于数据的存储，需先声明再使用；
1、全局变量：声明在类中，方法外，多个方法可同时使用,也被称作“属性”、类变量、成员变量等；可以不赋初始值；全局变量可以在类型前面加访问修饰符，来控制该变量被访问的范围：
例如：
private int i=100;
pulic String str=“”;
protected short t;
2、局部变量：声明在方法中，供当前方法使用； 声明是必须赋值或者使用时必须有赋值操作；
例如：
字节型：byte b=99;
短整型：int i=11;
整型： short t=5;
长整型：long l=1898989;
字符串变量：String str=“HELLO”;
浮点型：单精度：float f=1.78;
浮点型：双精度：double d=1.7878787878;
布尔类型： boolean b=true;
字符型：char c=‘A’;
4、Java中数据类型的分类；
Java中可以分为两大类数据类型：
1、基本数据类型：
整型：
字节型（8位）： byte -128到127之间的任意整数
短整型（16位）： short -32768~32767之间的任意整数
整型（32位）：int -2^31到2^31-1之间的任意整数
长整型（64位）：long -2^63到2^63-1之间的任意整数
浮点型：
单精度（32位）：float 32位单精度浮点数 根据IEEE754-1985标准
双精度（64位）：double
布尔类型： boolean （true/false）
字符型(16位)：char
2、引用数据类型：引用类型的内存单元中只存放对象的地址，而对象本身存贮在内存堆中，只是简单的引用对象的地址。非基本数据类型变量，都是引用数据类型；
（1）类class 例如：Object类 Date类
（2）接口interface
（3）数组array
5、基本数据类型之间的转换；
在Java中有如下几种转换方式：
1、隐式转换（亦称自动类型转换）：系统默认将其转换为我们需要的数据类型；
转换规则：从存储范围小的类型到存储范围大的类型。
具体规则为：byte→short(char)→int→long→float→double
也就是说 short类型的变量可以自动转换为 int 类型
例如：short t=10，10默认为int类型；
注意：在java中，整数默认为int类型，小数默认为double类型；
2、强制转换：在变量前加小括号，写转换类型，将其强制转换为指定类型；强制类型转换，也称显式类型转换，是指必须书写代码才能完成的类型转换。
该类类型转换很可能存在精度的损失，所以必须书写相应的代码，并且能够忍受该种损失时才进行该类型的转换。
转换规则:从存储范围大的类型到存储范围小的类型。
具体规则为：double→float→long→int→short(char)→byte
语法格式为：(转换到的类型)需要转换的值
例如：
(1)byte<- short<-int<-long(这里表示赋值方向)例如：
int i=10；short t=(short)i;
float f=(float)10.123;
long l=10; int i2=(int) l; short t2=(short) l;
(2) double->float;（double赋值给float类型）
float/double->（byte/short/int/long）例如：
float f=(float)10.123; float f=10.123f;
double d=10.123;int i3=(int) d;short t3=(short) d;long l2=(long) d; byte b=(byte) d;
（3）(byte/short/int/long/float/double)->char
char c='A';
c=(char) i;
特殊情况下：通过某些JavaAPI相关方法实现类型转换(不是基本数据类型之间的转换了)
例如：
double dRes=Double.valueOf("10.89");
6、关键字、标识符和常量用法；
1.关键字（词）：是java中特有的词语，是电脑语言（这里我们指Java）里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。
例如：
abstract 抽象类或方法
assert 用来查找内部程序错误
break 跳出一个switch或循环
byte 8位整数类型
case switch的一个分支
catch 捕获异常的try块子句
2.标识符
（1）由字母、数字、_下划线，或者$美元符号组成；
（2）不能以数字开头；
（3）区分大小写，长度无限制，但是要见名知意；
（4）不能是Java关键字或者保留字；
例如：
合法：Person 、 user_name、 _userName、$abc_123、userProject
非法：2Username、#Test、class 、void、pulic
p.s.类、方法、属性（变量）、常量命名规则：
类名：开头字母必须大写，后面每个单词首字母也大写，其他小写字母；
方法名：开头字母小写、后面每个单词首字母大写；
常量：所有字母大写；
3.常量：例如：当我们在项目中定义一个性别标识时，如男性:SEX_MEN="1" ，在我们使用时，永远不会修改这个数据，此时我们可以认为它就是常量；定义常量后，不 会被修改；（注意：之声明在类中作为全局变量使用）例如：
public static final String SEX_MAN="0";
7、运算符、表达式；
例如：
int i=6，j，k，m，n;
j = +i; //取原值，即j=6
k = -i; //取负值，即k=-6
m = i++; //先m=i,再i=i+1，即m=6，i=7
m = ++i; //先i=i+1,再m=i，即i=7，m=7
n = j--; //先n=j,再j=j-1，即n=6，j=5
n = --j; //先j=j-1,再n=j，即j=5，n=5;
p.s. ++/-- 在前时，则先运算再取值；在后时，则先取值再运算。
8、条件判断语句： if语句和switch语句；
(1)if语句结构
(2)switch流程控制语句结构：
主意：switch只能实现等值条件判断；而且表达式类型只能是int、char、byte类型变量；其中break表示退出当前判断的执行体；如果再循环中表示退出整个循环；
例如：
（3）三元运算符
语法为：条件表达式？表达式1：表达式2。
说明：问号前面的位置是判断的条件，判断结果为bool型，为true时调用表达式1，为false时调用表达式2。
例如：A>B ? 100 :200;
9、循环语句结构；
（1）for循环流程控制
p.s. for循环中另有此种循环方式: for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体,例如：
(2)while循环流程控制
(3)do…while循环流程
p.s. do...while循环与while循环的区别是do…while的循环主体至少运行一次。
10、字符串的定义和使用；
Java中String声明字符串两种方法及它们的区别 :
方法1：String msg = “Hello”；
直接赋值。该方法执行后会自动将字符串“Hello”保存在字符串池中。则第二次使用直接赋值时，先检测字符串池中是否已存在“Hello”，如果存在，则将堆地址赋给引用。
Public class StringDemo{
String msg1 = “Hello”；
String msg2 = “Hello”；
}
执行后使得msg1与msg2的指向的地址是相同的。即内存中只有一个Hello的值。被两个引用所指向。String类采用了共享的设计模式。
方法2：String msg =new String（“Hello”）；
构造方法赋值。该方法执行后，会开辟两个内存空间（耗费资源），msg会指向其中的一个，而另一个没有引用指向，就会成为垃圾内存被清理掉。使用构造方法声明的“Hello”不会自动保存到字符串池中，不能共享。
Public class StringDemo{
String msg1 = new String（“Hello”）；
String msg2 = new String（“Hello”）；
}
执行后，虽然内容一样，但是存放的地址是不一样的。他不会自动保存在字符串内存池中。
总结：综上所述，直接赋值及构造方法赋值，因保存到字符串池有差异，导致是否可以共享亦有差异，效果如下：
String str1=“weight”;
String str2=“weight”;
String str3=new String (“weight”);
System.out.println(str1==str2);//true
System.out.println(str2==str3);//false
字符串常用方法：
1、charCodeAt方法返回一个整数，代表指定位置字符的Unicode编码。 strObj.charCodeAt(index) 说明： index将被处理字符的从零开始计数的编号。有效值为0到字符串长度减1的数字。 如果指定位置没有字符，将返回NaN。 例如： var str = "ABC"; str.charCodeAt(0); 结果：65 2、fromCharCode方法从一些Unicode字符串中返回一个字符串。 String.fromCharCode([code1[,code2...]]) 说明： code1，code2...是要转换为字符串的Unicode字符串序列。如果没有参数，结果为空字符串。 例如： String.fromCharCode(65,66,112); 结果：ABp 3、charAt方法返回指定索引位置处的字符。如果超出有效范围的索引值返回空字符串。 strObj.charAt(index) 说明： index想得到的字符的基于零的索引。有效值是0与字符串长度减一之间的值。 例如： var str = "ABC"; str.charAt(1); 结果：B 4、slice方法返回字符串的片段。 strObj.slice(start[,end]) 说明： start下标从0开始的strObj指定部分其实索引。如果start为负，将它作为length+start处理，此处length为字符串的长度。 end小标从0开始的strObj指定部分结束索引。如果end为负，将它作为length+end处理，此处length为字符串的长度。 例如： 012345 var str = "ABCDEF"; str.slice(2,4); 结果：CD 5、substring方法返回位于String对象中指定位置的子字符串。 strObj.substring(start,end) 说明： start指明子字符串的起始位置，该索引从0开始起算。 end指明子字符串的结束位置，该索引从0开始起算。 substring方法使用start和end两者中的较小值作为子字符串的起始点。如果start或end为NaN或者为负数，那么将其替换为0。 例如： 012345 var str = "ABCDEF"; str.substring(2,4); // 或 str.substring(4,2); 结果：CD 6、substr方法返回一个从指定位置开始的指定长度的子字符串。 strObj.substr(start[,length]) 说明： start所需的子字符串的起始位置。字符串中的第一个字符的索引为0。 length在返回的子字符串中应包括的字符个数。 例如： 012345 var str = "ABCDEF"; str.substr(2,4); 结果：CDEF 7、indexOf方法放回String对象内第一次出现子字符串位置。如果没有找到子字符串，则返回-1。 strObj.indexOf(substr[,startIndex]) 说明： substr要在String对象中查找的子字符串。 startIndex该整数值指出在String对象内开始查找的索引。如果省略，则从字符串的开始处查找。 例如： 01234567 var str = "ABCDECDF"; str.indexOf("CD"，1); // 由1位置从左向右查找 123... 结果：2 8、lastIndexOf方法返回String对象中字符串最后出现的位置。如果没有匹配到子字符串，则返回-1。 strObj.lastIndexOf(substr[,startindex]) 说明： substr要在String对象内查找的子字符串。 startindex该整数值指出在String对象内进行查找的开始索引位置。如果省略，则查找从字符串的末尾开始。 例如： 01234567 var str = "ABCDECDF"; str.lastIndexOf("CD",6); // 由6位置从右向左查找 ...456 结果：5 9、search方法返回与正则表达式查找内容匹配的第一个字符串的位置。 strObj.search(reExp) 说明： reExp包含正则表达式模式和可用标志的正则表达式对象。 例如： var str = "ABCDECDF"; str.search("CD"); // 或 str.search(/CD/i); 结果：2 10、concat方法返回字符串值，该值包含了两个或多个提供的字符串的连接。 str.concat([string1[,string2...]]) 说明： string1，string2要和所有其他指定的字符串进行连接的String对象或文字。 例如： var str = "ABCDEF"; str.concat("ABCDEF","ABC"); 结果：ABCDEFABCDEFABC 11、将一个字符串分割为子字符串，然后将结果作为字符串数组返回。 strObj.split([separator[,limit]]) 说明： separator字符串或 正则表达式 对象，它标识了分隔字符串时使用的是一个还是多个字符。如果忽略该选项，返回包含整个字符串的单一元素数组。 limit该值用来限制返回数组中的元素个数。 例如： var str = "AA BB CC DD EE FF"; alert(str.split(" "，3)); 结果： AA,BB,CC 12、toLowerCase方法返回一个字符串，该字符串中的字母被转换成小写。 例如： var str = "ABCabc"; str.toLowerCase(); 结果：abcabc 13、toUpperCase方法返回一个字符串，该字符串中的所有字母都被转换为大写字母。 例如： var str = "ABCabc"; str.toUpperCase(); 结果：ABCABC
11、数组的定义和使用；
数组的定义和使用：
1.数组：它是一个变量，用于存储相同数据类型的一组数据；
2.建立java数组需要以下三个步骤：
声明数组
创建数组空间
初始化数组元素
3.数组的声明方式：
(1)数据类型 变量名[];
(2)数据类型[] 变量名;
例如：char s[]; char[] s;
Object p[]; Object[] p;
注意：
为数组开辟内存空间，在创建数组空间时必须为它指明数组的长度。
一个数组是一个对象，所以用new来创建数组
语法格式为：数组名 = new 数组元素类型[数组元素的个数]；
例如：
int[] MyIntArray;
MyIntArray =new int[4];
MyIntArray[0]=0;
MyIntArray[1]=1;
MyIntArray[2]=2;
MyIntArray[3]=3;
也可以在创建数组空间的时候，同时将初值给出来，例如：
int[] myIntArray={1,2,3,4};
存储空间的分配等价于使用new
有上面描述得知：java中数组长度不可变；
基本数据类型的数组元素会自动初始化成“空”值（对于数值，空值就是零；对于char，它是null；而对于boolean，它却是false）。
多维数组的定义和使用：
1. 定义方式：type 维数 arrayName；
例如：int [][] intArray；int[][][] a2；
2. 分配内存空间: 有两种方法：
a.直接为每一维分配空间：
如：int[][] a = new int[2][3]；
b.分别为每一维分配空间：
如：int[][] a = new int[2][ ]；
a[0] = new int[4];
a[1] = new int[3];
p.s.Java中多维数组被看作数组的数组。例如二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。
如：int[][] a = new int[2][3]；
a[0][0] a[0][1] a[0][2]
a[1][0] a[1][1] a[1][2]
3.多维数组（这里我们针对二维数组举例）初始化有两种方式：
例如：
（1）int[][] a = new int[2][3]； 先定义后再赋值；
（2）int a[][] = {{2,3,6}, {1,5}, {3,4}}; 定义时直接赋值；
关于java数组的常用操作方法
1. 声明一个数组
1 String[] arr1 = new String[5];
2 String[] arr2 = {"a","b","c", "d", "e"};
3 String[] arr3= new String[]{"a","b","c","d","e"};
2. 输出一个数组
1 int[] arr = { 1, 2, 3, 4, 5 };
2 String arrString = Arrays.toString(arr);
3
4 // 直接输出，为内存地址
5 System.out.println(arr);
6 // [I@139a55
7
8 System.out.println(arrString );
9 // [1, 2, 3, 4, 5]
3. 检查一个数组是否包含某值
1 String[] arr= { "a", "b", "c", "d", "e" };
2 boolean b = Arrays.asList(arr).contains("a");
3 System.out.println(b);
4 // true
4. 连接两个数组
1 //使用Apache Commons Lang library
2
3 1 int[] arr1 = { 1, 2, 3, 4, 5 };
4 2 int[] arr2= { 6, 7, 8, 9, 10 };
5 3 int[] combArr = ArrayUtils.addAll(arr1 , arr2);
// System.arraycopy()
1 static String[] concat(String[] a, String[] b) { 2 String[] c = new String[a.length + b.length]; 3 System.arraycopy(a, 0, c, 0, a.length); 4 System.arraycopy(b, 0, c, a.length, b.length); 5 return c; 6 }
1 //Arrays.copyOf()
2
3 public static int[] concat(int[] first, int[] second) {
4 int[] result = Arrays.copyOf(first, first.length + second.length);
5 System.arraycopy(second, 0, result, first.length, second.length);
6 return result;
7 }
5. 逆向输出一个数组
1 // Apache Commons Lang library
2
3 int[] arr= { 1, 2, 3, 4, 5 };
4 ArrayUtils.reverse(intArray);
5 System.out.println(Arrays.toString(intArray));
6 //[5, 4, 3, 2, 1]
1 int[] arr = { 1, 2, 3, 4, 5 };
2 int[] revArr = new int[arr.length];
3 for(int i = 0; i < arr.length; i++){
4 revArr[i] = arr[arr.length - i -1];
5 }
6 System.out.println(Arrays.toString(revArr));
7
8 //[5, 4, 3, 2, 1]
6. 移除数组中的元素
1 // Apache common lang
2
3 int[] arr= { 1, 2, 3, 4, 5 };
4 int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
5 System.out.println(Arrays.toString(removed))
p.s. 《java基础梳理-朝花夕拾》系列由何东飞根据自己工作几年以来对java的理解梳理而成，笔者闲暇时将持续更新，有不对的地方请各位指教。QQ:983489147