关键字
特点：完全小写的字母、有特殊颜色
标识符
一、标识符：自己起的名字都叫标识符
二、命名规则：
- 可以包含数字、字母、$、_，但不能以数字开头
- 不能是关键字
三、命名规范：
- 类名规范：首字母大写 后面每个单词首字母大写
- 变量名、方法名规范：首字母小写 后面每个单词首字母大写
常量
一、常量：在程序运行期间固定不变的量
二、常量的分类：
- 字符串常量：用双引号引起来的部分，如：“abc”、“123”
- 整数常量：直接写上去的数字，没有小数点，如：100、200、300、0、-250
- 浮点数常量：直接写上去的数字 有小数点，如：0.5、-3.14
- 字符常量：用单引号引起来的单个字符，如：‘A’、‘9’、‘b’、‘中’
【注】：字符串和字符的区别：字符串用
" "，字符用' '，" "里面的内容随便有多少都行(可以只含一个字符，也可以含多个字符，还可以什么都不含)，' '里面只能有一个字符（不能有多个，也不能没有）
- 布尔常量：只有两种取值：true、false
- 空常量：null，代表没有任何内容，也不能使用他
数据类型
一、基本数据类型（4类8种）：
- 整数型：byte、short、int、long
- 浮点型：float、double
- 字符型：char
- 布尔型：boolean
二、引用数据类型：类、数组、接口、字符串
【注】：
- 字符串不是基本类型 而是引用类型
- 浮点型可能只是一个近似值 并非精确值
- 数据范围与字节数不一定相关 例如float数据范围比long更广 但float是4字节 long是8字节
- 浮点数当中默认类型是double 如果一定要使用float类型 需要加上一个后缀F
如果是整数 默认为int类型 如果一定要使用long类型 需要加上一个后缀L
变量
一、变量：程序运行期间，内容可以发生改变的量
二、创建一个变量并且使用的格式：
数据类型 变量名称；//创建了一个变量
变量名称 = 数据值；//赋值，将右边的数据值赋值交给左边的变量
一步到位的格式：数据类型 变量名称 = 数据值；//在创建一个变量的同时,立刻放入指定的数据值
【注】：
- 如果创建多个变量，那么变量之间的名称不可以重复
- 对于float和long类型来说，字母后缀F和L不要丢掉
- 如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型的范围
- 没有进行赋值的变量，不能直接使用，一定要赋值之后才能使用
- 变量使用不能超过作用域的范围
作用域：从定义变量的一行开始 一直到直接所属的大括号结束为止- 可以通过一个语句（一个分号）来创建多个变量，但是一般情况下不推荐这么写
public class GuanJianZi {
public static void main(String[] args) {
//字符串常量
System.out.println("ABC");//ABC
System.out.println("");//
System.out.println("x");//x
//整数常量
System.out.println(30);//30
//浮点数常量
System.out.println(3.14);//3.14
//字符常量
System.out.println('A');//A
System.out.println('6');//6
//System.out.println('');错误！两个单引号之间''必须有内容 哪怕是一个空格都行 不能什么都没有
//System.out.println('ab');错误！两个单引号之间''只能有一个字符 不能没有 也不能有多个
//布尔常量
System.out.println(true);//true
System.out.println(false);//false
//空常量
//System.out.println(null);错误！因为不能使用空常量 所以不能直接打印输出null
//创建一个变量
//格式：数据类型 变量名称；
int num1;
//向变量中存入一个数据
//格式：变量名称 = 数据值
num1 = 10;
//当打印输出变量名称的时候 显示出来的是变量的内容
System.out.println(num1);//10
//改变变量当中本来的数字 变成新的数字
num1 = 20;
System.out.println(num1);//20
//使用一步到位的格式来定义变量
//格式：数据类型 变量名称 = 数据值；
int num2 = 25;
System.out.println(num2);//25
//改变变量当中本来的数字 变成新的数字
num2 = 35;
System.out.println(num2);//35
byte num3 = 30;//右侧数值的范围不能超过左侧数据类型的取值范围
System.out.println(num3);//30
//byte num3 = 400;错误！右侧数值的范围不能超过左侧数据类型的取值范围
short num5 = 50;
System.out.println(num5);//50
long num6 = 300000000L;//不写L会报错
System.out.println(num6);//300000000
float num7 =2.5F;//不写F会报错
System.out.println(num7);//2.5
double num8 = 1.2;
System.out.println(num8);//1.2
char zifu1 = 'A';
System.out.println(zifu1);//A
zifu1 = '中';
System.out.println(zifu1);//中
boolean var1 = true;
System.out.println(var1);//true
var1 = false;
System.out.println(var1);//false
//将一个变量的数据内容赋值给另一个变量
boolean var2 = var1;//右侧的变量名var1已经存在 里面装的是false布尔值 将右侧变量里面的false值向左交给var2变量进行存储
System.out.println(var2);//false
int num9 = 10;//创建一个新的变量 名叫num9
//int num9 = 20;错误！又创建了另一个新的变量 名字也叫num9
int num10;//定义了一个变量 但是没有进行赋值
//System.out.println(num10);错误！没有赋值的变量不能使用
//System.out.println(num11);错误！在创建变量之前不能使用这个变量
int num11 = 500;
System.out.println(num11);
{
int num12 = 60;
System.out.println(num12);//60
}
//System.out.println(num12);错误！已经超出了大括号 超出了变量的作用域
int num12 = 60;//程序运行到这里的时候 前面那个大括号里的内容就已经消失了
System.out.println(num12);//60
//同时创建了三个int类型的变量
int d,e,f;
//各自分别赋值
d = 10;
e = 20;
f = 30;
System.out.println(d);//10
System.out.println(e);//20
System.out.println(f);//30
//同时创建了三个全都是int类型的变量 并且同时各自赋值
int a = 10,b = 20,c = 30;
System.out.println(a);//10
System.out.println(b);//20
System.out.println(c);//30
}
}
数据类型转换
当数据类型不一样时 将会发生数据类型转换
- 自动类型转换（隐式）
（1）特点：代码不需要进行特殊处理 自动完成
（2）规则：数据范围从小到大 - 强制类型转换（显式）
（1）特点：代码需要进行特殊的格式处理 不能自动完成
（2）格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据
【注】：
- 强制类型转换一般不推荐使用 因为有可能发生精度损失、数据溢出
- byte/short/char这三种类型都可以发生数学运算 例如：
+，并且在运算时，都会先提升为int类型再计算- boolean类型不能发生数据类型转换
public class DateType {
public static void main(String [] args) {
System.out.println(1024);//这是一个整数 默认是int类型
System.out.println(3.14);//这是一个浮点数 默认是double类型
//左边是long类型 右边是默认的int类型 左右不一样
//一个等号代赋值 将右侧的int常量交给左侧的long变量进行存储
//int自动转换为long类型 符合数据范围从小到大的要求
//发生了自动类型转换
long num1 = 100;
System.out.println(num1);//100
//左边是double类型 右边是float类型 左右不一样
//float自动转换为double类型 符合数据范围从小到大的要求 也发生了自动类型转换
double num2 = 2.5F;
System.out.println(num2);//60
//左边是float类型 右边是long类型 左右不一样
//long自动转换为float类型 符合数据范围从小到大的要求 也发生了自动类型转换
float num3 = 30L;
System.out.println(num3);//30
//左边是int类型 右边是long类型 不一样
//long转换为int类型 数据范围不是从小到大 不能发生自动类型转换
//格式：范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的数据
int num4 = (int)100L;
System.out.println(num4);//100
int num5 = (int)6000000000L;
System.out.println(num5);//1705032704 数据溢出 数据溢出是说整数
int num6 =(int)3.99;
System.out.println(num6);//3 精度损失 并不是四舍五入 所有的小数位全都会损失掉 精度损失是说小数
char zifu1 = 'A';
System.out.println(zifu1 + 1);//66 表明'A'被当做65处理
//计算机的底层会用一个数字（二进制）来代表字符A 就是65
//一旦char类型进行了数学运算 那么字符就会按照一定的规则翻译成为一个数字
byte num7 = 40;
byte num8 = 50;
//byte result = num7 + num8;错误！
//首先将num7 num8各自由byte类型自动提升为两个int类型 再相加 得到的结果也是int类型 所以result应该是int类型
int result = num7 + num8;
System.out.println(result);//90
short num9 = 60;
//首先将num7 num9由byte short类型自动提升为两个int类型 再相加 得到的结果也是int类型 所以result2应该是int类型
//将int强制类型转换为short类型 【注意】：必须保证逻辑上真实大小本来就没有超过short范围 否则就会发生数据溢出
short result2 = (short)(num9 + num7);
System.out.println(result2);//100
}
}
编码表
数字和字符的对照关系表（编码表）：
- ASCII码：记住：48-‘0’、65-‘A’、97-‘a’
- Unicode码表：万国码 也是数字和符号的对照关系 开头0-127部分和ASCII完全一样 但是从128开始包含更多字符 还包含emoji
public class DateType {
public static void main(String [] args) {
//如何打印字符的ASCII码：加0
char zifu2 = '1';
System.out.println(zifu2 + 0);//49
char zifu3 = 'c';
//左侧是int类型 右边是char类型 由char类型转换为int类型 数据范围由小变大 发生了自动类型转换
int num = zifu3;
System.out.println(num);//99
char zifu4 = '中';
System.out.println(zifu4 + 0);//20013
}
}
运算符
一、运算符：进行特定操作的符号 如+
二、表达式：用运算符连起来的式子叫做表达式 如：20 + 5，a + b
三、四则运算：加+，减-，乘*，除/（被除数 / 除数 = 商……余），
四、取模（取余数）：%
五、首先计算得到表达式的结果 再打印输出这个结果
六、对于一个整数的表达式来说 除法用的是整除 整数除以整数结果仍然是整数 只看商 不看余数
七、只有对于整数的除法来说 取模运算符才有余数的意义
【注】：一旦运算当中有不同类型的数据 那么结果将会是数据类型范围大的那种
八、四则运算当中的加号+有常见的三种用法：
- 对于数值来说 那就是加法
- 对于字符char类型来说 在计算之前 char会被提升成为int 然后再计算
- char类型字符和int类型数字之间的对照关系表：ASCII Unicode
- 对于字符串来说 加号代表字符串连接操作
- 任何数据类型和字符串进行连接时 结果都会变成字符串
九、自增运算符：++，自减运算符：--
- 基本含义：让一个变量涨一个数字1 或者让一个变量减一个数字1
- 使用格式：写在变量名称之前 或者写在变量名称之后 例如：++num或者num++
- 使用方式：
（1）单独使用：不和其他任何操作混合 自己独立成为一个步骤
（2）混合使用：和其他操作混合 例如与赋值混合 或者与打印操作混合等 - 两种使用方式的区别：
（1）在单独使用的时候 前++和后++没有任何区别 也就是 ++num和num++是完全一样的
（2）在混合使用的时候 有【重大区别】：
a.如果是前++ 那么变量立刻马上+1 然后拿着结果进行使用 【先加后用】
b.如果是后++ 那么首先使用变量本来的数值 然后再让变量+1 【先用后加】
【注】：只有变量才能使用自增、自减运算符 常量不可发生改变 所以不能用 如：30++；是错的
十、赋值运算符分为：
- 基本赋值运算符
=：将右侧的数据交给左侧的变量 如：int a = 20; - 复合赋值运算符：
+=，-=，*=，/=，%=
【注】：
- 只有变量才能使用赋值运算符 常量不能进行赋值 即常量不能写在赋值运算符的左边
- 复合赋值运算符其中隐含了一个强制类型转换
十一、比较运算符：大于>，小于<，大于等于>=，小于等于<=，相等==，不相等!=
- 注意事项：
（1）比较运算符的结果一定是布尔值 成立就是true 不成立就是false
（2）如果进行多次判断 不能连着写 如：1 < x <3 是错误的！
十二、逻辑运算符：与&&（全都是true 才是true），或||（只要有一个是true就是true 全是false才是false），非！（取反）
- 与&&或||具有短路效果 如果根据左边已经可以判断得出最终结果 那么右边的代码将不再执行
【注意】：
- 逻辑运算符只能用于布尔值
- 与、或需要左右各自有一个布尔值 但是取反只要有唯一的一个布尔值即可
- 与、或两种运算符 如果有多个条件可以连续写 如：条件A && 条件B || 条件C
【tips】：对于1 < x <3的情况 应该拆成两个部分 然后使用与运算符连接起来
int x = 2;
1 < x && x < 3
十三、一元运算符：只要一个数据就可以操作的运算符 例如：取反 自增 自减
十四、二元运算符：需要两个数据才能进行操作的运算符 如：加法 赋值
十五、三元运算符：需要三个数据才可以进行操作的运算符
十六、三元运算符的格式：数据类型 变量名称 = 条件判断？表达式A ： 表达式B;首先判断条件是否成立：如果成立 为true 那么将表达式A的值赋值给左侧的变量 如果不成立为false 那么将表达式B的值赋值给左侧的变量 二者选其一
【注】：
- 必须同时保证表达式A和表达式B都符合左侧数据类型的要求
- 三元运算符的结果必须被使用
十七、定义一个方法的格式：（定义在class里面 main函数外面）
public static void 方法名称(){
方法体；
}
- 方法名称的命名规则和变量一样 使用小驼峰式
- 方法体：也就是大括号当中可以包含任意条语句
【注】：
- 方法定义的先后顺序无所谓
- 方法的定义不能产生嵌套包含关系 即 一个方法里面不能包含另一个方法
- 方法定义好了之后不会执行的 如果要想执行 一定要进行方法的调用
- 方法的调用格式：
方法名称();
public class DateType {
public static void main(String [] args) {
//两个常量之间可以进行数学运算
System.out.println(20 + 30);//50
//两个变量之间也可以进行数学运算
int a = 20;
int b = 30;
System.out.println(a - b);//-10
//常量和变量之间可以混合使用
System.out.println(a * 10);//200
int x = 10;
int y = 3;
int result3 = x / y;
System.out.println(result3);//3
int result4 = x % y;
System.out.println(result4);//1
//两边数据类型不一样 先转换为double + double 结果也是double
double result5 = x + 2.5;
System.out.println(result5);//12.5
//字符串类型的变量基本使用
//数据类型 变量名称 = 数据值；
String str1 = "Hello";
System.out.println(str1);//Hello
System.out.println("Hello" + "World");//HelloWorld
String str2 = "Java";
System.out.println(str2 + 20);//Java20
//优先级问题
//String + int + int 先计算第一个加号 计算结果为String 再计算String + int 结果为String
System.out.println(str2 + 20 + 30);//Java2030
System.out.println(str2 + (20 + 30));//Java50
int num10 = 10;
System.out.println(num10);//10
++num10;//单独使用 前++
System.out.println(num10);//11
num10++;//单独使用 后++
System.out.println(num10);//12
//与打印操作混合的时候
int num11 = 20;
//混合使用 先++ 变量立刻马上变成21 然后打印结果21
System.out.println(++num11);//21
System.out.println(num11);//21
int num12 = 30;
//混合使用 后++ 首先使用变量本来的30 然后再让变量+1得到31
System.out.println(num12++);//30
System.out.println(num12);//31
int num13 = 40;
//和赋值操作混合
int result6 = --num13;//混合操作 前-- 变量立刻马上-1变成39 然后将结果交给result6变量
System.out.println(result6);//39
System.out.println(num13);//39
int num14 = 50;
//混合使用 后-- 首先把本来的数字50 交给result7 然后我自己再-1
int result7 = num14--;
System.out.println(result7);//50
System.out.println(num14);//49
int m = 10;
int n = 20;
int result8 = ++m + n--;
System.out.println(result8);//31
System.out.println(m);//11
System.out.println(n);//19
byte num15 = 30;
//num15 = num15 + 5 即num15 = byte + int 转换为int + int 所以num15 = int 编译器自动强制类型转换num15 = （byte）int
num15 += 5;
System.out.println(num15);//35
//int result9 = 3 > 4 ? 2.5 : 10;//错误！必须同时保证表达式A和表达式B都符合左侧数据类型的要求
System.out.println(3 > 4 ? 2.5 : 10);//10.0
//m > n ? m : n;//错误！结果没有被使用 不仅没有打印出来 还没有赋值给别人 该语句使运算结果没法用
}
}
方法
一、方法确实就是若干语句的功能集合
二、方法好比是一个工厂：
蒙牛工厂： 原料：奶牛 饲料 水 产出物：奶制品
钢铁工厂： 原料：铁矿石 煤炭 产出物：钢铁建材
- 参数（原料）：就是进入方法的数据
- 返回值（产出物）：就是从方法中出来的数据
三、定义方法的完整格式：
修饰符 返回值类型 方法名称（参数类型 参数名称，……）{
方法体
return 返回值
}
- 修饰符：目前固定写法：public static
- 返回值类型：方法最终产生的数据结果是什么类型
- 方法名称：方法的名字 小驼峰命名
- 参数类型：进入方法的数据是什么类型
- 参数名称：进入方法的数据对应的变量名称
【注】：参数如果有多个 使用逗号进行分隔
- 方法体：方法需要做的事情 若干行代码
- return：一个作用是停止当前方法 第二个作用是将后面的返回值还给调用处
返回值：方法执行后最终产生的数据结果
【注】：return后面的返回值必须和方法名称前面的返回值类型保持对应
- 方法的调用格式
（1）单独调用：方法名称([实参]);
（2）打印调用：System.out.println(方法名称([实参]));
（3）赋值调用：数据类型 变量名称 = 方法名称(参数);
【注】：此前学习的方法 返回值类型固定写为void 这种方法只能够单独调用 不能进行打印调用或者赋值调用
- 方法参数问题：
（1）方法有参数：小括号当中有内容 当一个方法需要一些数据条件才能完成任务的时候 如：两个数字相加 必须知道两个数字各是多少才能相加
（2）方法无参数：小括号当中留空 一个方法不需要任何数据条件 自己就能独立完成任务 如：定义一个方法 打印固定10次HelloWorld - 使用方法时 所有注意事项：
（1）方法应该定义在类当中 但是不能在方法当中再定义方法 不能嵌套
（2）方法定义的前后顺序无所谓
（3）方法定义之后不会执行 如果希望执行 一定要调用：单独调用 打印调用 赋值调用
（4）如果方法有返回值 那么必须写上return 返回值;不能没有
（5）return后面的返回值数据 必须和方法的返回值类型对应起来
（6）对于一个void没有返回值的方法 不能写return后面的返回值 只能写return;可以省略return;不写
（7）一个方法当中可以有多个return语句 但是必须保证同时只有一个会被执行到 两个return不能连写
方法的重载
一、方法的重载：多个方法的名称一样 参数列表不一样
二、方法重载的好处：只需要记住唯一一个方法名称 就可以实现类似的多个功能
三、方法的重载与下列因素相关：
- 参数个数不同
- 参数类型不同
- 参数的多类型顺序不同
四、方法的重载与下列因素无关： - 与方法的返回值类型无关
- 与参数的名称无关
五、在调用输出语句时 println方法其实就是进行了多种数据类型的重载形式
六、长按Ctrl 在点击println可以查看println源代码
public class Method {
public static void main(String[] args) {
//单独调用
sum(10,20);//30
//打印调用
System.out.println(sum(10,20));//30
//赋值调用
int number = sum(15,25);
System.out.println(number);//40
System.out.println(sum(1,2.5));//3
}
//定义一个两个int数字相加的方法 三要素：返回值类型（int）、方法名称（sum）、参数列表（int a,int b）
public static int sum(int a,int b) {
System.out.println("方法执行啦！");
int result = a + b;
return result;
}
public static int getMax(int a,int b) {
if(a > b) {
return a;
//renturn a;错误！两个return不能连写
}else {
return b;
}
}
//方法的重载 参数的多类型顺序不同
public static int sum(int m,double n) {
return (int)(m + n);
}
}
数组
一、数组：是一种容器 可以同时存放多个数据值
二、数组的特点：
- 数组是一种引用数据类型
- 数组当中的多个数据 类型必须统一
- 数组的长度在程序运行期间不可改变
三、数组的初始化：在内存当中创建一个数组 并且向其中赋予一些默认值
- 动态初始化(指定长度)：在创建数组时 直接指定数组当中的数据元素个数
格式：数据类型[] 数组名称 = new 数据类型[数组长度];
（1）左侧的数据类型：也就是数组当中保存的数据全都是统一的什么类型
（2）左侧的中括号：代表我是一个数组
（3）左侧数组名称：给数组取一个名字
（4）右侧的new：代表创建数组的动作 在内存中 通过new关键字给数组开辟一些空间
（5）右侧的数据类型必须和左边的数据类型保持一致
（6）右侧中括号的长度：也就是数组当中 到底可以保存多少个数据 是一个int数据 - 静态初始化（指定内容）：在创建数组时 不直接指定数据个数多少 而是直接将具体的数据内容进行指定
标准格式：数据类型[] 数组名称 = new 数据类型[]{元素1，元素2……};
静态初始化的省略格式：数据类型[] 数组名称 = {元素1，元素2……};
【注】：
- 虽然静态初始化没有直接告诉长度 但是根据大括号里面的元素具体内容 系统可以自动推算出来长度
- 静态初始化没有直接指定长度 但是仍然会自动推算得到长度
- 静态初始化标准格式可以拆分为两个步骤：
数据类型[] 数组名称；
数组名 = new 数据类型[]{元素1，元素2……};
- 动态初始化也可以拆分为两个步骤：
数据类型[] 数组名称；
数组名称 = new 数据类型[数组长度];
- 静态初始化一旦使用省略格式 就不能拆分成为两个步骤了
- 使用建议：如果不确定数组当中的具体内容 用动态初始化 否则 已经确定了具体的内容 用静态初始化
四、数组的使用：
- 直接打印数组名称得到的是数组对应的内存地址值
- 访问数组元素的格式：
数组名称[索引值]
索引值：int数字 代表数组当中元素的编号 从0开始 一直到数组的长度－1为止 - 使用动态初始化数组时 其中的元素将会自动拥有一个默认值 规则如下：
（1）int类型默认为0
（2）float类型默认为0.0
（3）char类型默认为’\u0000’ 其中反斜杠u表示Unicode 0000表示十六进制
（4）boolean类型默认为false
（5）引用类型默认为null
【注】：静态初始化其实也有默认值 的过程 只不过系统自动马上将默认值替换成为了大括号当中的具体数值
五、如何获取数组的长度：格式：数组名称.length;，这将会得到一个int数字 代表数组的长度
六、数组一旦创建 程序运行期间长度不可改变
七、任何数据类型都能作为方法的参数类型 或者返回值类型
- 数组作为方法的参数 传递进去的其实就是数组的地址值
- 数组作为方法的返回值 传递进去的其实也是数组的地址值
public class Array {
public static void main(String[] args) {
//动态初始化一个double类型的数组 数组长度为10
double[] arrayA = new double[10];
//静态初始化一个数组 里面装的是int类型的数据 数据内容为5，10，15
int[] arrayB = new int[]{5,10,15};
//使用省略格式静态初始化一个数组 存放内容为"Hello""World""Java"
String[] arrayC = {"Hello","World","Java"};
System.out.println(arrayA);//[D@15db9742
System.out.println(arrayA[0]);//0.0
System.out.println(arrayA[1]);//0.0
System.out.println(arrayA[2]);//0.0
//数组经过动态初始化后 数组内容为默认值 通过以下方法给他们赋值
arrayA[0] = 1.1;
arrayA[1] = 2.2;
arrayA[2] = 3.3;
System.out.println(arrayA[0]);//1.1
System.out.println(arrayA[1]);//2.2
System.out.println(arrayA[2]);//3.3
System.out.println(arrayB);//[I@15db9742
//[代表数组 I代表全是int数据 @15db9742十六进制地址值
//直接打印数组元素
System.out.println(arrayB[0]);//5
System.out.println(arrayB[1]);//10
System.out.println(arrayB[2]);//15
//数组元素不一定需要打印 我们可以把它赋值给一个变量 给变量使用
int num1 = arrayB[1];
System.out.println(num1);//10
int len = arrayC.length;//获取数组长度
System.out.println(len);//3
//两个new创建了两个数组 arrayD中最开始存放的是长度为3的数组的地址 后来存放的是长度为5的数组的地址
//两个数组的长度都没有变 是arrayD指向的数组变了
int[] arrayD = new int[3];
System.out.println(arrayD.length);//3
arrayD = new int[5];
System.out.println(arrayD.length);//5
}
}
Arrays类
java.util.Arrays是一个与数组相关的工具类 里面提供了大量静态方法 用来实现数组常见的操作
public static String toString(数组)：将参数数组变成字符串 按照默认格式：[元素1，元素2，元素3，……]输出public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序
【注】：
- 如果是数值 sort默认按照升序从小到大
- 如果是字符串 sort默认按照字母升序
- 如果是自定义的类型 那么这个自定义的类需要有Comparable或者Comparator接口的支持
import java.util.Arrays;
public class ArraysClass {
public static void main(String[] args) {
int[] intArray = {10,20,30};
//将int[]数组按照默认格式变成字符串
String intString = Arrays.toString(intArray);
System.out.println(intString);//[10, 20, 30]
int[] array1 = {2,1,3,10,6};
Arrays.parallelSort(array1);//public static void sort(数组)没有返回值 所以他不会给你个新数组 而是在原来数组里给你排好序
System.out.println(Arrays.toString(array1));//[1, 2, 3, 6, 10]
String[] array2 = {"bbb","aaa","ccc"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2));//[aaa, bbb, ccc]
}
}
内存
java内存划分为五个部分：
- 栈（Stack）：存放的都是方法中的局部变量 方法的运行一定要在栈当中运行
局部变量：方法的参数 或者是方法{}内部的变量
局部的特点：有作用域 一旦超出作用域 立刻从栈内存中消失
为什么局部变量超出作用域就不能用：一旦超出作用域 他所属的栈内存立刻消失 - 堆（Heap）：凡是new出来的东西都在堆当中
堆内存里面的东西都有一个地址值：用十六进制表示
堆内存里面的数据都有默认值 默认规则见Array.java - 方法区（Method Area）：存储.class相关信息 包含方法的信息
- 本地方法栈（Native Method Stack）：与操作系统相关
- 寄存器（PC Register）：与CPU相关
异常Exception
一、数组索引越界异常(ArrayIndexOutOfBoundsException)： 数组的索引编号从0开始 一直到“数组的长度-1”为止 如果访问数组元素时 索引编号并不存在 那么就会发生数组索引越界异常
- 发生原因：索引编号写错了
- 解决办法：修改成为存在的正确索引编号
二、空指针异常(NullPointerException)：所有的引用类型变量都可以赋值为一个null值 但是代表其中什么都没有，数组必须进行new初始化才能使用其中的元素 如果只是赋值了一个null 没有进行new创建 那么就会发生空指针异常
- 原因：忘了new
- 解决办法：补上new
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
