二进制数只包含0和1,每一个0或者1都是一个bit(位)。
我们常用的十进制如何转换成二进制:
我们知道计算机中的数据都是由1或者0组成,每个0或1都是一个bit,每8个bit就是一个字节(byte)。
字节是数据存储的最小单位。
1 TB = 1024 GB---->1 GB = 1024 MB ---->1 MB = 1024 KB---->1 KB = 1024 B
启动:win+R
切换盘符: 盘符:
退出:exit
进入文件夹:cd+文件夹名称
查看目录:dir
清屏:cls
进入多级文件夹: cd+\IdeaProjects\javaBasic\java
返回上一层:cd…
返回根目录:cd
JRE(Java Runtime Enviroment),Java运行环境,如果只是需要在该计算机上运行Java应用,那么只需要安装JRE即可。
JDK(Java Development Kit),如果想要开发,就必须安装JDK。
特别注意:JDK安装路径最好不要有空格或者中文。
关键字的特点:
标识符:自己命名的类名,方法名等。
命名规则:
什么是常量?
常量就是在程序运行期间,不会改变的量。
常量的分类
字符串常量:凡是用双引号括起来的都是字符串常量,例如:“abc”,“110”,“Hello”…
字符常量:凡是用单引号括起来的单个字符,就叫字符常量。例如:‘A’,‘a’,‘1’,‘张’
整型常量:直接写上的数字,没有小数点。例如:123,200,-23
浮点型常量:直接写上的数字,有小数点。例如:3.14,0.0
布尔常量:true或false
空常量:null。代表没有任何数据
public class Demo01Const{
public static void main(String[] args){
// 字符串常量
System.out.println("ABC");
System.out.println("");
System.out.println("XYZ");
// 整数常量
System.out.println(50);
System.out.println(-30);
// 浮点常量
System.out.println(3.14);
System.out.println(0.0);
System.out.println(-24.0);
// 字符常量
System.out.println('A');
System.out.println('a');
//System.out.println('');单引号中间有且仅有一个字符,没有不行,编译出错
// 布尔常量
System.out.println(true);
System.out.println(false);
//空常量 null,不能直接打印
}
}
数据类型分为两类:
基本数据类型:
整型:byte,short,int,long
浮点型:float,double
字符型:char
布尔型:boolean
基本数据类型注意事项:
1.字符串不是基本数据类型,而是引用类型。
2.浮点型可能是一个近似值,而不是精确值。
3.数据范围不一定与字节数相关,例如float的范围比long要广,但是它只占4个字节。
4.浮点数默认是double类型,要使用float类型,需要加上后缀F/f,但是建议使用F。
5.整数默认为int类型,要使用long类型,需要加上后缀L/l,但是建议使用L。
public class Demo01DataType{
public static void main(String[] args){
System.out.println(1024);//默认是int类型
System.out.println(3.14);//默认是double类型
//左边是long类型,右边是int类型,数据类型不一致,会发生数据转换,
//int类型数据范围比long类型数据范围小,可以发生自动类型转换
long num1 = 10;
System.out.println(num1);
//左边是double类型,右边是float类型,数据类型不一致,可以发生数据类型转换
//float---->double float数据范围比double小,可以是发生自动类型转换
double num2 = 2.5F;
System.out.println(num2);
//左边是float类型,右边是long类型,数据类型不一致,可以发生数据类型转换
//long---->float long类型数据范围比float类型小,可以发生自动类型转换
float num3 = 30L;
System.out.println(num3);//30.0
}
}
什么是变量?
就是在程序运行期间,会发生改变的量。
创建一个变量的格式
① 数据类型 变量名称;//创建一个变量
变量名称 = 数据值;//赋值,将右边的数据值,赋值给左边的变量
② 数据类型 变量名称 = 数据值;
public class Demo02Variable{
public static void main(String[] args){
//使用格式①创建变量
int num1;
num1=1;
System.out.println(num1);
//改变变量当中的值
num1=20;
System.out.println(num1);
//使用格式②
int num2 = 5;
System.out.println(num2);
//byte num3 = 129;
//System.out.println(num3);
byte num3 = 64;
System.out.println(num3);//64
short num4 = 400;
System.out.println(num4);//400
long num5 = 3000000000L;
System.out.println(num5);//3000000000
float num6 = 3.2444F;
System.out.println(num6);//3.2444
double num7 = 3.14;
System.out.println(num7);//3.14
char ch1 = 'A';
System.out.println(ch1);//A
char ch2 = '2';
System.out.println(ch2);//2
char ch3 = '我';
System.out.println(ch3);//我
boolean b1 = true;
System.out.println(b1);//true
b1 = false;
System.out.println(b1);//false
boolean b2 = b1;
System.out.println(b2);//false
}
}
使用变量的注意事项
public class Demo03VariableNotice{
public static void main(String[] args){
int num1 = 10;
System.out.println(num1);
//int num1 = 20;错误,变量名不能重复。
float num2 = 3.14F;//如果不加F会产生错误。
System.out.println(num2);
long num3 = 30000000000L;
System.out.println(num3);
//byte num4 = 128; 注意byte的范围是-128~127,不能超出范围
byte num4 = 12;
System.out.println(num4);
short num5 = 400;
System.out.println(num5);
//没有赋值的变量不能使用
//int num6;
//System.out.println(num6);
//此时还没有命名变量,无法使用。
//System.out.println(num6);
int num6 = 2;
System.out.println(num6);
//可以这么使用,但是不建议。
int a = 10,b = 20,c = 30;
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
什么是数据类型转换?
当数据类型不一样时,就会发生数据类型转换。
数据类型转换的分类:
public class Demo01DataType{
public static void main(String[] args){
System.out.println(1024);//默认是int类型
System.out.println(3.14);//默认是double类型
//左边是long类型,右边是int类型,数据类型不一致,会发生数据转换,
//int类型数据范围比long类型数据范围小,可以发生自动类型转换
long num1 = 10;
System.out.println(num1);
//左边是double类型,右边是float类型,数据类型不一致,可以发生数据类型转换
//float---->double float数据范围比double小,可以是发生自动类型转换
double num2 = 2.5F;
System.out.println(num2);
//左边是float类型,右边是long类型,数据类型不一致,可以发生数据类型转换
//long---->float long类型数据范围比float类型小,可以发生自动类型转换
float num3 = 30L;
System.out.println(num3);//30.0
}
}
2.强制类型转换(显式):
①特点:代码需要进行格式处理,不能自动完成
②格式:数据类型 变量名称 = (范围小的类型)原本范围大的数据
注意事项:
public class Demo02DataType{
public static void main(String[] args){
//左边是int类型,右边是long类型,会发生数据类型转换
//long---->int ,long类型范围比int类型大,不能发生自动类型转换,需要强制类型转换
//进行格式处理: 范围小的数据类型 范围小的变量名 = (范围小的数据类型)原本范围大的数据;
int num =(int)100L;
System.out.println(num);
//左边是int类型,右边是long类型,会发生数据类型转换
//long--->int long比int范围要大,所以发生强制类型转换
//但是发生了数据溢出,因为int类型装不下6000000000
int num1 = (int) 6000000000L;
System.out.println(num1);//1705032704
//float---->int 强制转换,发生精度丢失,这里不是四舍五入
int num2 = (int) 3.99F;
System.out.println(num2);//3
//我们都知道计算机底层都是二进制数,所以A也是以二进制数的形式来存储,
char ch1 = 'A';
System.out.println(ch1+1);//66 证明这里的'A'被当做65来进行运算
byte b1 = 40;
byte b2 = 50;
int result1 = b1+b2;//会报错,不兼容的类型。原因:就是第三个注意事项,当进行数学运算时,b1和b2都已经被提升成了int类型,左右两边类型不一致
//需要发生强制类型转换,所以把result1的类型转换成int
System.out.println(result1);
short s1 = 60;
//short result2 = b1+s1; 同上,会报错,如果想要的结果是short类型,那么必须进行强制类型转换
short result2 =(short)(b1+s1);
System.out.println(result2);
}
}
什么是ASCII码表?
ASCII:American Standard Code of Information Inchange 美国信息交换标准代码
还有Unicode表,就是数字和字符的对照关系表。
public class Demo03DataTypeChar{
public static void main(String[] args){
char ch1 = '1';
System.out.println(ch1+0);
char ch2 = 'A';
System.out.println(ch2+2);//67
//左边是int类型,右边是char类型,左右不一致,发生数据类型转换
//char---->int 范围小向范围大转换,自动转换,不需要强制类型转换
int num = 'c';
System.out.println(num);//99
int ch3 = '中';
System.out.println(ch3);//20013
}
}
什么是运算符?
就是进行特定操作的符号。
什么是表达式?
就是用运算符连接起来的式子。
四则运算符,+,-,*,/,%;其中包括加,减,乘,除,%代表取模,即取余数。
public class Demo04Operator{
public static void main(String[] args){
System.out.println(20+30);//50
int a = 10;
int b = 20;
//会先计算表达式的值,再进行打印
System.out.println(a-b);//-10
System.out.println(a*10);//100
//除法,只看商
int result1 = 10/3;
System.out.println(result1);//3
//如果想要获得余数,用取模运算
int x = 14;
int y = 3;
int result2 = x%y;
System.out.println(result2);//2
//int + double ---->double + double ----->double
double result3 = x + 2.5;
System.out.println(result3);//16.5
}
}
"+"常见的三种用法:
public class Demo05Plus{
public static void main(String[] args){
String str1 = "Hello";
System.out.println("Hello");
System.out.println("Hello"+"World");//HelloWorld
String str2 = "Java";
//String + int --->String + String ---->String
System.out.println(str1+20);//Java20
System.out.println(str1+20+30);//Java2030
System.out.println(str1+(20+30));//Java50
}
}
使用方式:++可以在前,也可以在后,例如:++n或者n++。
使用区别:
1.单独使用:++在前和在后没有任何区别,独自形成一个步骤(前提是不与任何其他操作混合)
2.混合使用:当混合使用时,++在前和在后有【重大区别】:
a.++在前时,变量立刻+1,然后再参与其他运算 【先加后用】
b.++在后时,变量首先按照原来的值参与其他运算,然后再+1 【先用后加】
注意事项:只有是变量才能使用自增、自减符号,常量无法使用。
public class Demo06Operator{
public static void main(String[] args){
//单独使用的情况,没有区别
int num1 = 10;
++num1;
System.out.println(num1);//11
int num2 = 20;
num2++;
System.out.println(num2);//21
System.out.println("==============================================================");
//混合使用,例如与打印操作混合
int num3 = 30;
System.out.println(++num3);//31
System.out.println(num3);//31
int num4 = 40;
System.out.println(num4++);//40
System.out.println(num4);//41
System.out.println("==============================================================");
//和赋值操作混合
int num5 = 50;
int result1 = num5++;
System.out.println(result1);//50
System.out.println(num5);//51
int num6 = 60;
int reuslt2 = --num6;
System.out.println(reuslt2);//59
System.out.println(num6);//59
System.out.println("==============================================================");
int x = 10;
int y = 20;
int result = --x + y++;
System.out.println(result);//29
System.out.println(x);//9
System.out.println(y);//21
//30++; //只有变量才能自增或自减,常量使用会编译报错。
}
}
1.基本赋值运算符
就是=,代表把右边的数据值赋值给左边的变量
2.复合赋值运算符
+=: a += 5 相当于 a = a + 5;
-=: a -= 5 相当于 a = a - 5;
*=: a *= 5 相当于 a = a * 5;
/=: a /= 5 相当于 a = a / 5;
%=: a += 5 相当于 a = a % 5;
注意事项:
1.只有变量可以使用复合赋值运算,常量不可以使用。
2.复合赋值运算实际含有一个隐式的数据类型转换。
public class Demo07Operator{
public static void main(String[] args){
int a = 10;
a += 5;
System.out.println(a);//15
int b = 13;
b %= 4;
System.out.println(b);//1
//复合赋值运算中隐含了一个强制类型转换
byte x = 12;
//x += 5;
//相当于 x = x + 5;
// byte = byte + int ;
//byte = int + int ;
//byte = int ;
//byte = (byte)int;
x += 5;
System.out.println(x);//17
}
}
比较运算符: > , < , >= , <= , == ,!=; 与:&&; 与、或具有短路效果:就是根据左边的表达式已经能够判断出结果,那么后边的表达式将不再运行,节省性能。 格式: 注意事项: 顺序结构:程序由上至下运行。 4.标准的switch语句 switch case注意事项: 1.for循环 2.while循环 3.do-while循环 4.条件控制语句 continue: break和continue的区别: 6.循环嵌套 1.方法的定义 2.方法 方法好比是一个工厂。 参数(原料):就是进入方法的数据。 定义方法的完整格式: 修饰符:现阶段的固定写法,public static 注意:return后面的“返回值”,必须和方法名称前面的“返回值类型”,保持对应。 定义一个两个int数字相加的方法。三要素: 方法的三种调用格式。 注意:此前学习的方法,返回值类型固定写为void,这种方法只能够单独调用,不能进行打印调用或者赋值调用。 3.方法的参数 无参数:小括号当中留空。一个方法不需要任何数据条件,自己就能独立完成任务,就是无参数。 4.return语句 5.使用方法时注意事项 什么是方法的重载? 方法的重载和下列因素有关: 方法的重载和下列因数无关: 什么是数组? 数组的特点: 定义一个数组有两种常见的方式: 2.静态初始化数组(指定内容): 静态初始化数组的省略格式: Java中内存划分为5个部分: Java中数组的内存图: 2.两个数组的内存图: 数组的两种常见问题: 2.空指针异常:如果没有对数组进行初始化,访问元素的时候,会产生空指针异常。NullPointerException 数组的长度: 遍历数组:对数组中每一个元素进行逐个处理。 练习: 2.求出数组中的最小值: 3.数组的反转: 数组也可以作为方法的参数:
注意事项:
1.比较运算符的结果一定是boolean类型。
2.如果进行多次判断,不能像数学中连写,如1public class Demo08Operator{
public static void main(String[] args){
int x = 10;
int y = 20;
System.out.println(x > y);//false
System.out.println(x < y);//true;
System.out.println(x >= 100);//false
System.out.println(x <= 10);//true;
System.out.println(10 == 10);//true
System.out.println(20 != 20);//false
}
}
逻辑运算符
或:||;
非:!;public class Demo09Logic{
public static void main(String[] args){
System.out.println(true && true);//true
System.out.println(true && false);//false
System.out.println(3 < 4 && 10 < 100);//true
System.out.println(true || true);//true
System.out.println(true || false);//true
System.out.println(false || false);//false
System.out.println(!true);//false
System.out.println(!false);//true
System.out.println("======================");
//短路效果:
int a = 10;
System.out.println(3 > 4 && ++a > 1);//false
System.out.println(a);//10
int b = 20;
System.out.println(3 < 4 || b++ > 1);//true
System.out.println(b);//20
}
}
三元运算符
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
1.表达式A和表达式B必须同时满足左边的数据类型,否则编译报错。
2.三元运算符的结果必须被使用,要么赋值,要么打印等,不能独立存在public class Demo10Operator{
public static void main(String[] args){
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println("最大值是:" + max);//20
//注意事项1:
//int max = 3 > 4 ? 2.5 : 10;//错误写法,必须同时满足左边的int类型
//注意事项2:
System.out.println(a > b ? a : b);//正确写法 将会打印20
//a > b ? a : b;错误写法,编译报错
}
}
程序流程
顺序结构
#### 选择结构 ####
1.单if语句
public class Demo02If{
public static void main(String[] args){
System.out.println("今天我准备去网吧");
int age = 17;
if(age >= 18){
System.out.println("年龄满18才能进入网吧");
}
System.out.println("回家");
}
}
public class Demo03IfElse{
public static void main(String[] args){
int age = 20;
if(age >= 18){
System.out.println("可以进入网吧");
}else{
System.out.println("不能进入网吧");
}
}
}
public class Demo04IfElseExt{
public static void main(String[] args){
int x = 15;
int y;
if(x >= 3){
y = 2*x+1;
} else if (-1 < x && x < 3){
y = 2*x;
} else {
y = 2*x-1;
}
System.out.println("结果是"+ y);
}
}
public class Demo07Switch{
public static void main(String[] args){
int num = 4;
switch(num){
case 1:
System.out.println("今天是星期一");
break;
case 2:
System.out.println("今天是星期二");
break;
case 3:
System.out.println("今天是星期三");
break;
case 4:
System.out.println("今天是星期四");
break;
case 5:
System.out.println("今天是星期五");
break;
case 6:
System.out.println("今天是星期六");
break;
case 7:
System.out.println("今天是星期七");
break;
default:
System.out.println("数据不合理");
break;//不写这个break不会报错,但是强烈建议写上。
}
}
}
①case后面的数值不能重复
②case后面可以是基本类型也可以是引用类型:
基本类型:byte,short,char,int
引用类型: String,enumpublic class Demo08SwitchNotice{
public static void main(String[] args){
int num = 3;
switch(num){
case 2:
System.out.println("BBB");
break;
case 3:
System.out.println("AAA");
case 1:
System.out.println("CCC");
break;
default:
System.out.println("DDD");
break;
}
System.out.println("具有穿透功能的switch");
}
}
循环结构
/*
循环结构:
for循环
for(初始化语句①;条件判断②;步进语句④){
循环体③
}
*/
public class Demo09For{
public static void main(String[] args){
for(int i=1;i<=100;i++){
System.out.println("我错了!请原谅我把!"+i);
}
}
}
/*
while循环:
标准格式:
while(条件判断){
循环体
}
扩展格式:
初始化语句;
while(条件判断){
循环体;
步进语句;
}
*/
public class Demo10While{
public static void main(String[] args){
int i = 1;
while(i<=10){
System.out.println("我错了!"+ i );
i++;
}
}
}
/*
doWhile循环
do{
循环体
步进语句
}while(条件判断)
dowhile循环一上来就先执行一次do里面的内容,再进行条件判断是否继续循环
*/
public class Demo11DoWhile{
public static void main(String[] args){
int i = 1;
do{
System.out.println("起来吧,原谅你了");
i++;
}while(i <= 10);
}
}
break:
①在switch语句中使用,一旦执行,整个switch将被打断
②在循环中使用,一旦执行,整个循环被打断public class Demo13Break{
public static void main(String[] args){
for(int i=1;i<=10;i++){
if(i==4){
break;
}
System.out.println("hello"+i);
}
}
}
在循环中使用,一旦执行,表示跳出当次循环,继续下一次循环public class Demo14Continue{
public static void main(String[] args){
for(int i = 1;i <= 10;i++){
if(i == 4){
continue;
}
System.out.println(i+"层到了");
}
}
break是打断,终止整个循环结构,执行break后将不再执行任何循环体内容。
continue是跳出当次循环,继续下一次循环,执行continue后,循环还可以继续。
5.死循环public class Demo15DeadLoop{
public static void main(String[] args){
while(true){
System.out.println("I love Java!");
}
//System.out.println("hello");这是错误写法,循环不结束,这句话不会执行,会编译报错
}
}
public class Demo16LoopHourAndMinute {
public static void main(String[] args){
for(int hour = 0 ;hour < 24;hour++){
for(int minute = 1;minute < 60;minute++){
System.out.println( hour + "点" + minute + "分");
}
}
}
}
方法
定义格式:
public static void 方法名称() {
方法体
}
调用格式:方法名称();
注意事项:
public class Demo01Method {
public static void main(String[] args) {
printMethod();
}
public static void printMethod() {
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 20; i++) {
System.out.print("*");
}
System.out.println();
}
}
}
方法其实就是若干语句的功能集合。
蒙牛工厂 原料:奶牛、饲料、水
产出物:奶制品
钢铁工厂 原料:铁矿石、煤炭
产出物:钢铁建材
返回值(产出物):就是从方法中出来的数据。
修饰符 返回值类型 方法名称(参数类型 参数名称, …) {
方法体
return 返回值;
}
返回值类型:也就是方法最终产生的数据结果是什么类型
方法名称:方法的名字,规则和变量一样,小驼峰
参数类型:进入方法的数据是什么类型
参数名称:进入方法的数据对应的变量名称
PS:参数如果有多个,使用逗号进行分隔
方法体:方法需要做的事情,若干行代码
return:两个作用,第一停止当前方法,第二将后面的返回值还给调用处
返回值:也就是方法执行后最终产生的数据结果
返回值类型:int
方法名称:sum
参数列表:int a, int b
public class Demo02MethodDefine {
public static void main(String[] args) {
// 单独调用
sum(10, 20);
System.out.println("===========");
// 打印调用
System.out.println(sum(10, 20)); // 30
System.out.println("===========");
// 赋值调用
int number = sum(15, 25);
number += 100;
System.out.println("变量的值:" + number); // 140
}
public static int sum(int a, int b) {
System.out.println("方法执行啦!");
int result = a + b;
return result;
}
}
有参数:小括号当中有内容,当一个方法需要一些数据条件,才能完成任务的时候,就是有参数。
例如两个数字相加,必须知道两个数字是各自多少,才能相加。
例如定义一个方法,打印固定10次HelloWorld。public class Demo03MethodParam {
public static void main(String[] args) {
method1(10, 20);
System.out.println("==============");
method2();
}
// 两个数字相乘,做乘法,必须知道两个数字各自是多少,否则无法进行计算
// 有参数
public static void method1(int a, int b) {
int result = a * b;
System.out.println("结果是:" + result);
}
// 例如打印输出固定10次文本字符串
public static void method2() {
for (int i = 0; i < 10; i++) {
System.out.println("Hello, World!" + i);
}
}
}
/*
题目要求:定义一个方法,用来【求出】两个数字之和。(你帮我算,算完之后把结果告诉我。)
题目变形:定义一个方法,用来【打印】两个数字之和。(你来计算,算完之后你自己负责显示结果,不用告诉我。)
注意事项:
对于有返回值的方法,可以使用单独调用、打印调用或者赋值调用。
但是对于无返回值的方法,只能使用单独调用,不能使用打印调用或者赋值调用。
*/
public class Demo04MethodReturn {
public static void main(String[] args) {
// 我是main方法,我来调用你。
// 我调用你,你来帮我计算一下,算完了之后,把结果告诉我的num变量
int num = getSum(10, 20);
System.out.println("返回值是:" + num);
System.out.println("==============");
printSum(100, 200);
System.out.println("==============");
System.out.println(getSum(2, 3)); // 正确写法
getSum(3, 5); // 正确写法,但是返回值没有用到
System.out.println("==============");
// 对于void没有返回值的方法,只能单独,不能打印或者赋值
// System.out.println(printSum(2, 3)); // 错误写法!
// System.out.println(void);
// int num2 = printSum(10, 20); // 错误写法!
// int num3 = void;
// void num4 = void;
}
// 我是一个方法,我负责两个数字相加。
// 我有返回值int,谁调用我,我就把计算结果告诉谁
public static int getSum(int a, int b) {
int result = a + b;
return result;
}
// 我是一个方法,我负责两个数字相加。
// 我没有返回值,不会把结果告诉任何人,而是我自己进行打印输出。
public static void printSum(int a, int b) {
int result = a + b;
System.out.println("结果是:" + result);
}
}
public class Demo04MethodNotice {
public static int method1() {
return 10;
}
public static void method2() {
// return 10; // 错误的写法!方法没有返回值,return后面就不能写返回值。
return; // 没有返回值,只是结束方法的执行而已。
}
public static void method3() {
System.out.println("AAA");
System.out.println("BBB");
// return; // 最后一行的return可以省略不写。
}
public static int getMax(int a, int b) {
/*int max;
if (a > b) {
max = a;
} else {
max = b;
}
return max;*/
if (a > b) {
return a;
} else {
return b;
}
}
}
方法的重载
多个方法的名称一样,但是数据列表不一样。
1.和参数个数有关。
2.和多种参数的顺序有关。
3.和参数类型有关。
1.和参数的名称无关。
2.和返回值类型无关。public class Demo01MethodOverload {
public static void main(String[] args) {
System.out.println(sum(10,20));
System.out.println(sum(10,20,30));
System.out.println(sum(10,20,30,40));
}
public static int sum(int a,int b){
return a + b;
}
//与参数的名称无关
// public static int sum(int x , int y){
// return x + y;
// }
//与返回值类型无关
// public static double sum(double a , double b){
// return a + b;
// }
//与参数类型有关
public static int sum(double a ,double b){
return (int)(a + b);
}
//与多个不同类型参数的顺序有关
public static int sum(double a,int b){
return (int)(a + b);
}
public static int sum(int a , double b){
return (int)(a + b);
}
public static int sum(int a,int b,int c){
return a + b + c;
}
public static int sum(int a,int b,int c,int d){
return a + b + c + d;
}
}
数组
数组是一个容器,用来存储同一类型的数据。
1.数组是一种引用类型数据。
2.数组中的数据是属于同一种类型。
3.数组的长度不可改变。
1.动态初始化数组(指定长度):
数据类型[] 数组名称 = new 数据类型[数组长度];public class Demo01Array {
public static void main(String[] args) {
//创建一个长度为10的int类型数组
int[] arr1 = new int[10];
//创建一个长度为20的double类型数组
double[] arr2 = new double[20];
//创建一个长度为5的String类型数组
String[] arr3 = new String[5];
}
}
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,…};public class Demo02Array {
public static void main(String[] args) {
//创建一个数组,是int类型数据,里面装 5,10,15
int[] arr1 = new int[]{ 5 , 10 , 15};
//创建一个数组,里面装String类型数据,里面装"Hello" ,"World" ,"Java"
String[] arr2 = new String[]{"Hello" , "World" , "Java"};
}
}
数据类型[] 数组名称 = {元素1,元素2,…};public class Demo03Array {
public static void main(String[] args) {
//省略格式创建一个给int数组,使用省略格式,里面是5,6,7
int[] arr1 = {5,6,7};
//静态初始化的标准格式可以拆分为两个步骤
int[] arr2;
arr2 = new int[]{5,6,7};
//动态初始化也可以拆分为两个步骤
int[] arr3;
arr3 = new int[10];
//静态初始化一旦使用省略格式,不能再拆分为两个步骤
// int[] arr4;
// arr4 = {5,6,7};//编译报错,这种格式不被允许
}
}
1.栈(Stack):存储局部变量,方法的运行在栈中。
2.堆(Heap):凡是new出来的东西,都在堆中。
3.方法区:存储.class文件中的信息,包含方法信息。
4.本地方法栈:和操作系统有关。
5.寄存器:和CPU有关。
1.一个数组的内存图:public class Demo01ArrayOne {
public static void main(String[] args) {
int[] arr1 = new int[3];
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
arr1[1] = 10;
arr1[2] = 20;
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
}
}
public class Demo02ArrayTwo {
public static void main(String[] args) {
int[] arrA = new int[3];
System.out.println(arrA[0]);
System.out.println(arrA[1]);
System.out.println(arrA[2]);
arrA[1] = 10;
arrA[2] = 20;
System.out.println(arrA[0]);
System.out.println(arrA[1]);
System.out.println(arrA[2]);
System.out.println("==================");
int[] arrB = new int[3];
System.out.println(arrB[0]);
System.out.println(arrB[1]);
System.out.println(arrB[2]);
arrB[1] = 10;
arrB[2] = 20;
System.out.println(arrB[0]);
System.out.println(arrB[1]);
System.out.println(arrB[2]);
}
}
public class Demo03ArraySame {
public static void main(String[] args) {
int[] arrA = new int[3];
System.out.println(arrA[0]);//0
System.out.println(arrA[1]);//0
System.out.println(arrA[2]);//0
arrA[1] = 10;
arrA[2] = 20;
System.out.println(arrA[0]);//0
System.out.println(arrA[1]);//10
System.out.println(arrA[2]);//20
System.out.println("==============");
int[] arrB = arrA;
System.out.println(arrB[0]);//0
System.out.println(arrB[1]);//10
System.out.println(arrB[2]);//20
arrB[1] = 100;
arrB[2] = 200;
System.out.println(arrB[0]);//0
System.out.println(arrB[1]);//100
System.out.println(arrB[2]);//200
System.out.println("==============");
}
}
1.数组索引越界异常:访问数组元素时,索引编号不存在,那么将会发生数据索引越界异常。ArrayIdexOutOfBoundsException
原因:索引值不正确。
解决办法:修改索引值。public class Demo01ArrayIndexOutOfBoundsException {
public static void main(String[] args) {
int[] arr = {15, 25, 35};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//错误写法,会引发数组索引越界异常
System.out.println(arr[3]);
}
}
原因:没有对数组进行初始化,数组是null值。
解决办法:对数组进行初始化。public class Demo02NullPointerException {
public static void main(String[] args) {
int[] arr = null;
//arr = new int[3];
System.out.println(arr[0]);
}
}
获取数组的长度通过其length属性,即可获得。
int length = arr.length;
注意事项:
数组一旦创建,其长度是不可变的。public class Demo03ArrayLength {
public static void main(String[] args) {
//创建一个长度为3的数组
int[] arr = new int[3];
System.out.println(arr.length);
//这里并不是数组的长度由3变成5,而是又创建了一个
// 长度为5的数组,变量arr的地址值发生了改变。
arr = new int[5];
System.out.println(arr.length);
}
}
public class Demo04Array {
public static void main(String[] args) {
int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
1.求出数组中的最大值:public class Demo05ArrayMax {
public static void main(String[] args) {
int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22};
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]>max){
max = arr[i];
}
}
System.out.println("最大值是:"+ max );
}
}
public class Demo06ArrayMin {
public static void main(String[] args) {
int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22};
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]
/*
* 数组的反转:
* 本来的样子:[1,2,3,4]
* 反转的样子:[4,3,2,1]
* 不能使用新的数组
*
* 思路:
* 1.数组的反转是两个对称位置的数据交换
* 2.需要两个索引,min和max
* 3.需要一个临时变量
* 4.条件判断,当min小于max时才交换,否则不交换
* */
public class Demo07ArrayReverse {
public static void main(String[] args) {
int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22};
//遍历原来的数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
//反转
for (int min=0,max = arr.length-1; min < max ; min++ , max-- ){
int temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
}
//遍历新的数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
当调用方法的时候,向小括号传参,事实上传递的是数组在堆内存中的地址值。
数组也可以作为方法的返回值:
其实返回的也是数组在堆内存中的地址值。public class Demo01ArrayParam {
public static void main(String[] args) {
int[] arr = {10,20,30};
myPrint(arr);
int[] result = sumAndAvg(arr);
System.out.println(result);
myPrint(result);
}
public static void myPrint(int[] arr){
//事实上传递的是地址值
System.out.println(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static int[] sumAndAvg(int[] arr){
int[] arr1 = null;
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
int avg = sum / arr.length;
arr1 = new int[]{sum , avg};
return arr1;
}
}