java语言概述
命令行指令
win+r cmd
**dir **列出当前目录下的文件
**md **创建目录
**rd **删除目录(目录内容需为空，否则先del)
**del **删除文件（*.txt删除所有txt文件）
**cd **进入指定目录
**cd…**退回到上一级目录
**cd\ **退回到根目录
**exit **退出dos命令行
***** 通配符
编译运行
javac test.java
java test
javac.exe java.exe
.java文件（源文件）----------->.class文件（字节码文件）--------------->结果
编译 运行
文档注释（java特有）
/**
@author 指定Java程序的作者
@version 指定源文件的版本
*/
可被解析，生成一套以网页文件形式体现的该程序的说明文档
API文档
GraalVM SDK Java API 参考 (oracle.com)
对第1个java程序进行总结
（1）java程序编写-编译-运行的过程
编写：我们将编写的java代码保存在以“.java”结尾的源文件中
编译：使用javac.exe命令编译我们的java源文件。格式：javac 源文件名.java
运行：使用java.exe命令解释运行我们的字节码文件。格式：java 类名
（2）在一个java源文件中可以声明多个class
但是，只能最多有一个类声明为public的，而且要求声明为public的类的类名必须与源文件名相同
（3）程序的入口是main( )方法。格式是固定的。
public static void main(Strin[ ] args)
（4）输出语句：
System. out. println(" "); 先输出数据，然后换行
System. out. println( );换行的作用
System.out.print(" ");不换行只输出数据
（5）每一个执行语句都以;结束
（6）编译的过程：编译以后，会生成一个或多个字节码文件。字节码文件的文件名与java源文件中的类名相同。
（7）代码语法结构不对（编译时报错）
java基本语法
关键字和保留字
- 用于定义数据类型的关键字
class interface enum byte short int long float double char boolean void
- 用于定义流程控制的关键字
if else switch case default while do for break continue return
- 用于定义访问权限的关键字
private protected public
- *用于定义数据类型的字面值
true false null
- 保留字
goto const
标识符
-
凡是自己可以起名字的地方都叫标识符（变量、方法、类、接口名）
-
定义合法标识符规则：
- 由26个英文字母大小写，0-9，_或$组成
- 数字不可以开头
- 不可以使用关键字和保留字，但能包含关键字和保留字
- java中严格区分大小写，长度无限制
- 标识符不能包含空格
- 命名规范：
- 包名：多单词组成时所有字母都小写xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写XxxYyyZzz
- 变量名、方法名：多单词组成时，第1个单词首字母小写，第2个单词开始每个单词首字母大写xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接XXX_YYY_ZZZ
变量
分类
基本数据类型：
-
整型 byte \ short \ int \ long
-
浮点型 float \ double
-
字符型 char
-
布尔型 boolean
引用数据类型：
-
类 class
-
接口 interface
-
数组 array
string属于引用数据类型
变量在声明中的位置区分：成员变量 vs 局部变量
使用
整型：
byte(1个字节) -128到127
short(2个字节)
int(4个字节)
long(8个字节) 声明long型变量，必须以小写l或大写L结尾
整型常量默认类型为int型
浮点型：
float(4个字节) 单精度，尾数可以精确到7位有效数字（表示数值的范围比long还大）
double(8个字节) 双精度，精度是float的两倍，通常采用此类型
java的浮点型常量默认为double型，声明float型常量，须后加f或F
浮点型常量默认类型为double型
字符类型：
（声明一个字符or转义字符 ）
char(2个字节) 声明char型变量通常使用’'(单引号)(内部只能写一个字符)
布尔型：
boolean 只能取两个值之一：true、false
常常在条件判断、循环结构中使用
转换
基本数据类型变量间转换
自动类型提升：
byte、char、short–> int–> long–> float–> double
特别的：当byte、char、short三种类型的变量做运算时，结果为int类型
强制类型转换：
class Hello4{
public static void main(String[] args){
double d1 = 12.3;
int il = (int)d1;//损失精度
System.out.println(il);
}
}
基本数据类型与String间转换
String可以和8种数据类型变量做运算，且运算只能是连接运算： + （ 运算的结果String类型 ）
+的两边都不是String则做加法运算，eg：
char c = 'a';//97 A:65
int num = 10 ;
String str = "hello";
System.out.println(c+num+str);//107hello//加法，连接
System.out.println(c+str+num);//ahello10//连接，连接
System.out.println(c+(num+str));//a10hello//连接，连接
System.out.println("* *");//* *
System.out.println('*'+'\t'+'*');//93
System.out.println('*'+"\t"+'*');//* *
进制与进制间的转换
-
二进制（binary）:0b1001
-
十进制：123
-
八进制：0127
-
十六进制：0x21F
运算符
算术运算符
略
赋值运算符
-
支持连续赋值
-
short s=1;s=s+1;与short s=1;s+=1;不同:
s=s+1这句先执行s+1然后把结果赋给s，由于1为int类型，所以s+1的返回值是int，编译器自动进行了隐式类型转换，所以将一个int类型赋给short就会出错。
而s+=1不同由于是+=操作符，在解析时候s+=1就等价于s = (short)(s+1)。
比较运算符（关系运算符）
-
区分==和=
-
比较运算符的结果是boolean型，也就是要么是true，要么是false
-
< > >= <= 只能在数值类型的数据间使用
-
== != 还可以使用在其他引用类型变量之间
逻辑运算符
| &逻辑与 | 有false则false |
| &&短路与 | 和逻辑与规则一样 但是，左边遇到false右边就不计算了 |
| |逻辑或 | 有true则true |
| ||短路或 | 与逻辑或规则一样 但是左边遇到true右边就不计算 |
| ！逻辑非 | 遇true就是false，遇false就是true |
| ^逻辑异或 | 相同为false，不同为true |
位运算符
-
<<:在一定范围内，每左移1位，相当于*2
-
>>:在一定范围内，每右移1位，相当于/2
2*8最高效的方式：
2<<3
8<<1
三元运算符
（条件表达式）? 表达式1 : 表达式2；
运算符的优先级
- 只有单目运算符、三目运算符、赋值运算符是从右向左运算的
流程控制
分类
-
顺序结构（从上到下依次执行）
-
分支结构（根据条件，选择性地执行某段代码；有if…else和switch-case两种分支语句）
-
循环结构（根据循环条件重复性地执行某段代码；有while、do…while、for三种循环语句）（注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素）
使用
分支结构
if-else
略
switch-case
switch(score / 60){
case 0:
System.out.println(""很遗憾，您没有及格！);
break;
case 1:
System.out.printin("恭喜您，您及格了！");
break;
}
-
switch结构中的表达式，只能是如下的6种数据类型之一：byte、short、char、int、枚举类型、string类型
-
case之后只能声明常量，不能声明范围
循环结构
for
略
do while
略
while
while循环初始化条件出循环后也可调用
break
label:for(int i = 1;i <= 5;i++){
for(int j = 1;j <= 5 -i ;j++){
System.out.print(" ");
break label; //结束指定标识的一层循环结构
}
}
continue
略
数组
特点
（0）有序排列
（1）数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
（2）创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址
（3）数组的长度一旦确定，就不能修改
（4）我们可以直接通过下标（或索引）的方式调用指定位置的元素，速度很快
（5）数组分类：
-
按照维度：一维数组、二维数组、三维数组……
-
按照元素的数据类型分：基本数据类型元素的数组、应用数据类型元素的数组（即对象元素）
使用
声明和初始化
int[][] arr1 = new int[][]{{1,2,3},[4,5},{6,7,8}}; // 静态初始化
String[][] arr2 = new String[3][2]; // 动态初始化1
String[][] arr2 = new String[3][]; // 动态初始化2
int[] arr = new int[3]{1,2,3};//错误
arr2=arr1;//支持数组间赋值
使用指定位置的元素
int[][] arr1 = new int[][]{{1,2,3},[4,5},{6,7,8}};
System.out.println(arr1[0][1]); //2
String[][] arr2 = new String[3][];
arr3[1] = new String[4];
System.out.println(arr3[1][0]);
获取数组的长度
int[][] arr4 = new int[][]{{1,2,3},[4,5},{6,7,8}};
System.out.printin(arr4.length); //3
System.out.printin(arr4[1].length); //2
遍历数组
for(int i=0;i<arr4.length;i++){
for(int j = 0;j < arr4[i].length;j++){
System.out.print(arr4[i][j] + " ");
}
System.out.println();
}
数组元素的默认初始化值
一维
数组元素是整型：0 //byte、short、int、long
数组元素是浮点型：0.0
数组元素是char型：0（ASCii码值）
数组元素是boolean型：false
引用数据类型：null
二维
规定：二维数组分为外层数组的元素，内层数组的元素
外层元素：arr[0]、arr[1]等 外层元素的初始化值为;地址值
内层元素：arr[0][0]、arr[1][2]等 内层元素的初始化值为：与一维数组初始化情况相同
//两种初始化方式
int arr[][] = new int[4][3];
System.out.println(arr); // 二维数组的首地址值
System.out.println(arr[0]); // 第一行的首地址值
System.out.println(arr[0][0]); // 0
String[][] arr2 = new String[3][];
System.out.println(arr2[1]); // 外层元素的初始化值为：null
System.out.println(arr2[1][1]);//内层元素的初始化值为：不能调用，否则报错
double[][] arr2 = new String[3][];
System.out.println(arr2[1]); //null
System.out.println(arr2[1][0]); //报错
数组的内存解析
常见算法
元素赋值
杨辉三角、回形数
求最值、平均数、总和等
略
数组的复制、反转、查找
反转
//数组的反转(方法1)
for(int i = 0;i < arr.length / 2;i++){
String temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
//数组的反转(方法2)
for(int i = 0，j = arr.length-1;i < j;i++,j--){
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
查找
线性
String dest= "6";
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
if(dest.equals(arr[i])){
System.out.printin("找到了指定的元素，位置为：" + i);
isFlag = false;
break;
}
}
if(isFlag){
System.out.println("很遗憾，没有找到哦！");
}
二分法
//前提：所要查找的数组必须有序
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while(head <= end){
int middle = (head + end) / 2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定的元素，位置为：" + middle);
isFlag1 = false;
break;
}
else if(arr2[middle] > dest1){
end = middle - 1;
}
else{
head = middle + 1;
}
}
if(isFlag1){
System.out.println("很遗憾，没有找到哦！");
}
排序
选择排序：直接选择排序、堆排序
交换排序：冒泡排序、快速排序
插入排序：直接插入排序、折半插入排序、Shell排序（希尔）
归并排序：
桶式排序：
基数排序：
时间复杂度
快排：O(nlog2n)
冒泡：O(n2)
冒泡
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
for(int i = 0;i < arr.length - 1;i++){
for(int j = 0;j < arr.length - 1 - i;j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
Arrays工具类
java.util.Arrays类即为操作数组的工具包，包含了用来操作数组（比如排序和搜索）的各种方法
（1）boolean isEquals = Arrays.equals(arr1,arr2); 判断两个数组是否相等
（2）System.out.println(Arrays.toString(arr)); 输出数组信息
（3）Arraya.fill(arr,10); 将指定值填充到数组之中
（4）Arrays.sort(arr);对数组进行排序(从小到大)（快排）
（5）int index = Arrays.binarySearch(arr,10)二分查找(返回负数表示没找到)
其他
Scanner使用
-
导包
inport java.util.Scanner; -
实例化
Sanner scan = new Scanner(System.in); -
调用Scanner类的相关方法，来获取指定类型的变量
int num = scan.nextInt();
随机数的获取
double value = Math.random();//[0.0,1.0)
获取[a,b]范围整数公式:(int)(Math.random()*(b-a+1)+a)
获取随机数10-99：
int value =(int)(Math.random()*90+10)
判断输入的字符串是否是规定的
Scanner scan = new Scanner(System.in);
System.out.println("请问您是否爱java");
String islovejava = scan.next();
if(islovejava.equals("是")){
System.out.println("java也爱你哟！");
}
开平方
i = Math.sqrt(m);
1505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
