一、命令行的使用
呈现目录:dir
创建目录:md + 文件目录名
进入到文件夹里面:cd + 目录1\目录2\
回到上一层目录:cd..
回到根目录:cd/ 或 cd\
删除文件目录(必须是空的):rd 文件目录名
删除当前目录下指定文件:del + 文件名
二、字面量
package cn.bwl.zimianliang;
public class ZiMianLiangDemo {
public static void main(String[] args) {
// 数据在程序中的书写格式
//1.整数
System.out.println(50);
//2.小数
System.out.println(50.3);
//3.字符 单引号括起来 只能写一个字符
System.out.println('s');
System.out.println(' ');
System.out.println('a');
// System.out.println('');
System.out.println('\n');
System.out.println('b');
System.out.println('\t');
//4.字符串 双引号括起来 里面随便写
System.out.println("中");
System.out.println("");
System.out.println("国");
System.out.println(" ");
System.out.println("HelloWorld");
//5.布尔 结果为:true/false
System.out.println(true);
System.out.println(false);
//6.空 要输出的话按字符串的形式输出
System.out.println("null");
// System.out.println(null);
}
}
三、变量的使用
package cn.bwl.variable;
public class Variable {
public static void main(String[] args) {
//1.存储一个数据的
//数据类型 变量名 = 数据;
//2.存放整形的一个变量
int i = 12;
System.out.println(i);
//3.存放小数的变量
double d = 3.2;
System.out.println(d);
System.out.println("-----------------------------");
//4.优点:方便管理代码
int a = 666;
System.out.println(a);
System.out.println(a);
System.out.println(a);
System.out.println(a);
System.out.println(a);
System.out.println("-----------------------------");
//5.变量里的内容是可以被替换的
int s = 23;
System.out.println(s);
s = 78;
System.out.println(s);
s = s + 1;
System.out.println(s);
System.out.println("-----------------------------");
//6.需求:钱包里有9.5,先放进去10元,又拿出来 5元,现在钱包里还有多少
double money = 9.5;
money = money + 10;
money = money - 5;
System.out.println(money);
}
}
注意事项
package cn.bwl.variable;
public class VariableDemo2 {
public static void main(String[] args) {
//变量的注意事项
//1.先声明,后使用
int s = 23;
System.out.println(s);
//2.什么类型的变量,只能存什么类型的数据
// int a = 23.4;
int b = 334;
//3.变量存在访问范围,同一个范围内,多个变量的名字不能一样4
{
int c = 34;
// int c = 78;
System.out.println(c);
System.out.println(s);
}
// System.out.println(c);
b = 67;
//4.变量定义时可以不给赋初始值,但使用时变量里必须有值
int f;
// System.out.println(f);
f = 39;
System.out.println(f);
}
}
int 中国 = 65; // int 2w = 34; // double class = 58; int Class = 5555;int $ = 58; // int _ = 38;
标识符的定义规范
- 变量名:首字母小写,驼峰,int studyVariable = 89;
- 类名:驼峰
八种数据类型
byte short int long
float double
char
boolean
package cn.bwl.variable;
public class VariableDemo2 {
public static void main(String[] args) {
//八种基本数据类型
//1.整形 byte short int long
byte b = 127;//byte -128~127
// byte b2 = 128;//越界
short s = 3846;
// short s2 = 37823; //越界
int i = 37842923;
int i2 = -435567899;
// long l = 2343567858;//因为整数类型默认int ,所以后面要加个L/l
long l2 = 3724689L;
//2.浮点型 默认double
float f = 23460.45F;//定义float 要加F/f
double d = 3456765.685;
//3.字符型
char c = 'd';
char c2 = '中';
// char c3 = "中国";
//4.布尔类型
boolean bb = true;
boolean bb2 = false;
//补充引用数据类型
String ss = "中国";
}
}
四、类型转换
1.自动类型转换
package cn.bwl.type;
public class TypeDemo1 {
public static void main(String[] args) {
//1.自动类型转换 byte-short-int-long-float-double
// 数据类型范围小的转换给数据类型范围大的
byte b = 47;
int i = b;
System.out.println(i);
int i2 = 3445;//4位
double d = i2;//8位
System.out.println(d);
//char可以赋给int
char c = 'a';//2字节 16位 00000000 01100001
int i3 = c;//4字节 32位 00000000 00000000 00000000 01100001
System.out.println(i3);
}
}
2,表达式类型转换
package cn.bwl.type;
public class TypeDemo2 {
public static void main(String[] args) {
//表达式自动类型转换
byte b = 32;
int i = 25;
long l = 234L;
long rs1 = b + i + l;//转换成范围最大的数据类型
System.out.println(rs1);
double d = b + i + 10.0;
System.out.println(d);
byte b2 = 127;
byte b3 = 27;
// byte = b2 + b3;//byte short char在表达式中直接转换成int类型,
int rs2 = b2 + b3;//因为计算结果超过了byte类型的范围
}
}
3.强制类型转换
package cn.bwl.type;
public class TypeDemo3 {
public static void main(String[] args) {
//强行将类型范围大的转换成类型范围小的
int i = 20;
// byte b = i;
byte b = (byte) i;//强制类型转换
System.out.println(b);
//强制类型转换,数据可能有溢出
int i2 = 340;
byte i3 = (byte) i2;
System.out.println(i3);
//强制类型转换,浮点型转换成整形
double d = 43.5;
int i4 = (int) d;
System.out.println(i4);
}
}
五、运算符
1.算术运算符,+ 做连接符
package cn.bwl.yunsuanfu;
public class YunSuanfuDemo1 {
public static void main(String[] args) {
//算术运算符 + - * / %
int i = 10;
int j = 2;
System.out.println(i + j);
System.out.println(i - j);
System.out.println(i * j);
System.out.println(i / j);
System.out.println(5 / 2);
System.out.println(5.0 / 2);
int a = 5;
int b = 2;
System.out.println(1.0 * a / b);
System.out.println(i % j);
System.out.println(a % b);
System.out.println("--------------------------");
//+ 作连接符,连接字符串
//能算则算,不能算就在一起
int g = 5;
System.out.println(5 + "abc" );//5abc
System.out.println("sdfdg" + 5);//sdfdg5
System.out.println("baowenli" + 5 + "liu");//baowenli5liu
System.out.println(5 + 'a' + "baowenli");// a = 97 , 102baowenli
}
}
2.自增自减
package cn.bwl.yunsuanfu;
public class YunSuanFuDemo2 {
public static void main(String[] args) {
//自增、自减运算符
int a = 10;
System.out.println(a++);
System.out.println(++a);
int b = 10;
System.out.println(b--);
System.out.println(--b);
System.out.println("-----------------");
int x = 12;
int rs1 = x++;//先用后加
System.out.println(x);//13
System.out.println(rs1);//12
int x2 = 12;
int rs2 = ++x2;//先加后用
System.out.println(x2);//13
System.out.println(rs2);//13
System.out.println("--------------------------");
//运算
int m = 5;
int n = 3;
//分三步
//m 5 6 5 4
//n 3 4 3
// 6 - 5 + 5 - 4 + 4 +3
int result = ++m - --m + m-- - ++n + n-- +3;
System.out.println(result);//9
System.out.println(m);//4
System.out.println(n);//3
//练习
int c = 10;
int d = 5;
//c 10 11 12 11
//d 5 4 5
// 10 + 12 - 4 - 5 + 1 + 12
int result2 = c++ + ++c - --d - ++d + 1 + c--;
System.out.println(result2);//26
System.out.println(c);//11
System.out.println(d);//5
}
}
3. 扩展赋值运算符
package cn.bwl.yunsuanfu;
public class YunSuanFuDemo3 {
public static void main(String[] args) {
//扩展赋值运算符
//+=
double a = 10;
double b = 2;
a += b;//a = (double)(a + b);
System.out.println(a);
//-=
double i = 10;
double j = 2;
i -= j;//i = (double)(i + j);
System.out.println(i);
int m = 10;
int n = 5;
// m *= n;//m = (int)(m * n);50
// m /= n;//m = (int)(m / n);2
m %= n;//m = (int)(m % n);
System.out.println(m);
}
}
4.关系运算符
package cn.bwl.yunsuanfu;
public class YunSuanFuDemo4 {
public static void main(String[] args) {
//关系运算符
int a = 10;
int b = 5;
boolean c = a > b;
System.out.println(a >= b);//true
System.out.println(2 >= 2);//true
System.out.println(a < b);//false
System.out.println(a <= b);//false
System.out.println(2 <= 2);//true
System.out.println(a != b);//true
System.out.println(2 != 2);//false
System.out.println(5 == 5);//true
System.out.println(a = b);//z注意 =是赋值
}
}
5.逻辑运算符
package cn.bwl.yunsuanfu;
public class YunSuanFuDemo5 {
public static void main(String[] args) {
//逻辑运算符
//1,与 & ,同真才为真
double d = 9.9;
int i = 10;
boolean re = d >= 10 & i <=20;
System.out.println(re);//false
//2,或 | ,同假才为假
double d1 = 9.9;
int i1 = 10;
boolean re1 = d1 >= 10 & i1 <=9;
System.out.println(re1);//false
//3.非 ! 取反
System.out.println(!false);
System.out.println(!true);
System.out.println();
//4.异或 结果不同才为true
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
//5.短路与 && 左为false,则右边不执行
int j = 1;
System.out.println(2 >= 3 && ++j <= 10);//false
System.out.println(j);
//6.短路或 || 左边为真,则右边不执行
System.out.println(2 <= 3 || ++j <= 10);//true
System.out.println(j);
}
}
6.三元运算符 以及优先级
package cn.bwl.yunsuanfu;
public class YunSuanFuDemo6 {
public static void main(String[] args) {
//三元运算符 优先级
double d = 90;
String re1 = d > 60 ? "成绩合格" : "成绩不及格";
System.out.println(re1);
int a =10;
int b =20;
int re2 = a > b ? a : b;
System.out.println(re2);
//输出三个数中最大的
int i = 32;
int j = 66;
int k = 65;
//先比较两个数的大小
int teap = i > j ? i : j;
//再拿teap和第三个数比较
int re3 = teap > k ? teap : k;
System.out.println(re3);
//优先级 && 高于 ||
System.out.println(2 > 3 || 4 > 5 && 7 > 4);//false
System.out.println((2 < 3 || 4 < 5) && 7 > 4);//true
}
}
7.键盘录入
8.习题
package cn.bwl.practice;
import java.util.Scanner;
public class Question1 {
public static void main(String[] args) {
//自己写的时候没有用到强制类型转换
System.out.println("请输入父亲的身高:");
Scanner sc = new Scanner(System.in);
int father = sc.nextInt();
System.out.println("请输入母亲的身高:");
int mother = sc.nextInt();
// int father = 177;
// int mother = 165;
int son = (int)((father + mother) * 1.08 / 2);
int daughter = (int)((father * 0.923 + mother) / 2);
System.out.println("儿子的身高:" + son + "cm");
System.out.println("女儿的身高:" + daughter + "cm");
}
}
package cn.bwl.practice;
import java.util.Scanner;
public class Question1 {
public static void main(String[] args) {
//自己写的时候没有用到强制类型转换
System.out.println("请输入父亲的身高:");
Scanner sc = new Scanner(System.in);
int father = sc.nextInt();
System.out.println("请输入母亲的身高:");
int mother = sc.nextInt();
// int father = 177;
// int mother = 165;
int son = (int)((father + mother) * 1.08 / 2);
int daughter = (int)((father * 0.923 + mother) / 2);
System.out.println("儿子的身高:" + son + "cm");
System.out.println("女儿的身高:" + daughter + "cm");
}
}
package cn.bwl.practice;
public class Question3 {
public static void main(String[] args) {
//要定义变量表示菜的价格
//使用三元运算符
// int money = 24 * 3 + 3 * 8 + 3 * 5;
// if (money > 100) {
// money *= 0.9;
// System.out.println("小明要付" + money + "元");
// }
// System.out.println("小明要付" + money + "元");
int fish = 24;
int peanut = 8;
int rice = 3;
int money = fish * 3 + peanut * 3 + rice * 5;
System.out.println("打折前的价格" + money);
int fee = money > 100 ? (int)(money * 0.9) : money;
System.out.println("打折后的价格" + fee);
}
}
六、流程控制语句
1.分支结构
if
package cn.bwl.branch;
public class IfDemo1 {
public static void main(String[] args) {
//1.判断温度是否大于37度
int temp = 40;
if (temp > 39.8){
System.out.println("此人温度不正常");
}
//2.判断钱包余额
int money = 99;
if (money > 99){
System.out.println("可以给出红包");
} else {
System.out.println("余额不足");
}
//3.判断公司员工的绩效
int score = 98;// [60,70) D,[70,80)C,[80,90)B,[90,100]A
if (score >= 60 && score < 70){
System.out.println("您的绩效为D");
} else if (score >= 70 && score < 80){
System.out.println("你的绩效为C");
} else if (score >= 80 && score < 90){
System.out.println("你的绩效为C");
} else if (score >= 90 && score <= 100){
System.out.println("你的绩效为C");
} else {
System.out.println("输入的数据有误");
}
}
}
switch
package cn.bwl.branch;
public class SwitchDemo2 {
public static void main(String[] args) {
String week = "周八";
switch (week){
case "周一" :
System.out.println("埋头苦干,解决bug");
break;
case "周二" :
System.out.println("求大牛程序员帮忙");
break;
case "周三" :
System.out.println("今晚啤酒、龙虾、小烧烤");
break;
case "周四" :
System.out.println("主动帮助新来的女程序解决bug");
break;
case "周五" :
System.out.println("今晚吃鸡");
break;
case "周六" :
System.out.println("与王婆介绍的小芳相亲");
break;
case "周日" :
System.out.println("郁郁寡欢,准备上班");
break;
default:
System.out.println("你输入的星期数有问题");
}
}
}
switch的注意事项:
package cn.bwl.branch;
public class SwitchDemo3 {
public static void main(String[] args) {
//switch的注意事项
//1.switch后面括号里的只能是 byte short int char 枚举 String 不能是 float double long 型的
int a = 10;
double d = 98.8;
double q = 0.1;
double p = 0.2;
double c = q + p;
System.out.println(c);
switch (a){
case 10:
System.out.println(666);
}
//2.case 后面的值为字面量,字面量的值也不同,不能是变量
int i = 20;
switch (i) {
case 10:
System.out.println(i);
case 20:
System.out.println(i);
}
//3.不要忘记写break,否则可能会发生穿透
String week = "周三";
switch (week){
case "周一" :
System.out.println("埋头苦干,解决bug");
break;
case "周二" :
System.out.println("求大牛程序员帮忙");
break;
case "周三" :
System.out.println("今晚啤酒、龙虾、小烧烤");
//break;
case "周四" :
System.out.println("主动帮助新来的女程序解决bug");
break;
case "周五" :
System.out.println("今晚吃鸡");
break;
case "周六" :
System.out.println("与王婆介绍的小芳相亲");
break;
case "周日" :
System.out.println("郁郁寡欢,准备上班");
break;
default:
System.out.println("你输入的星期数有问题");
}
}
}
用穿透性解决难题
package cn.bwl.branch;
public class SwitchDemo4 {
public static void main(String[] args) {
//switch穿透性解决一些问题
String week = "周三";
switch (week){
case "周一" :
System.out.println("埋头苦干,解决bug");
break;
case "周二" :
case "周三" :
case "周四" :
System.out.println("请求大牛程序员帮忙");
break;
case "周五" :
System.out.println("自己整理代码");
break;
case "周六" :
case "周日" :
System.out.println("郁郁寡欢,准备上班");
break;
default:
System.out.println("你输入的星期数有问题~~~");
}
}
}
2.循环结构
for循环批量表示数据
package cn.bwl.xunhuan;
public class ForDemo1 {
public static void main(String[] args) {
for(int i = 0; i < 3; i++){
//0 1 2
System.out.println("HelloWorld1");
}
System.out.println("----------------");
for(int i = 1; i <= 5; i++){
//i 1 2 3 4 5
System.out.println("HelloWorld2");
}
System.out.println("----------------");
for(int i = 1; i <= 10; i += 2){
//i 1 3 5 7 9
System.out.println("HelloWorld3");
}
}
}
package cn.bwl.xunhuan;
public class ForDemo2 {
public static void main(String[] args) {
//1.输出1~100之间的数
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
//2.求1~100之间的和
//定义一个变量表示数字的和
int sum = 0;
//3.找到1~100中的所用数
for (int i = 1; i <= 100; i++) {
sum +=i;
}
System.out.println(sum);
//4.求1~100之间的奇数和
//定义一个变量表示奇数和
int sum2 = 0;
for (int i = 1; i <= 100; i += 2) {
sum2 += i;
}
System.out.println(sum2);
//5.求1~100之间的奇数和
//定义一个变量表示奇数和
int sum3 = 0;
//表示1~100之间的数
for (int i = 1; i <= 100; i++) {
//if判断是否为奇数
if (i % 2 ==1){
sum3 += i;
}
}
System.out.println(sum3);
}
}
while
package cn.bwl.xunhuan;
public class WhileDemo3 {
public static void main(String[] args) {
int i = 0;
while (i < 5){
System.out.println("HelloWorld!");
i++;
}
}
}
package cn.bwl.xunhuan;
public class WhileDemo4 {
public static void main(String[] args) {
//while循环的小案例,0.1cm厚的纸,折叠多少次达珠穆朗玛峰的高度8848860
//定义两个变量表示山和纸
int mountain = 8848860;
double paper = 0.1;
//定义一个变量记录执行的次数
int count = 0;
//while循环控制 (不知道执行次数)
while (paper < mountain){
paper *= 2;
count++;
}
System.out.println("折叠了" + count + "次");
System.out.println("纸张厚度为" + paper);
}
}
do-while
package cn.bwl.xunhuan;
public class DoWhileDemo5 {
public static void main(String[] args) {
int i = 0;
do {
System.out.println("HelloWorld1");
}while (i > 3);
//do-while会先执行一次,再进行判断
do {
System.out.println("HelloWorld2");
}while (false);
System.out.println("-----------------------");
//三种循环的区别
//for while 几乎无差别,for 知道循环的执行次数
for (int i1 = 0; i1 < 3; i1++) {
System.out.println("HelloWorld3");
}
// System.out.println(i1);
int j = 0;
while (j<3){
System.out.println("HelloWorld4");
j++;
}
System.out.println(j);//3
}
}
死循环
package cn.bwl.xunhuan;
public class SiXunHuanDemo6 {
public static void main(String[] args) {
//死循环用在服务器程序,类似于百度,微信
// for ( ; ; ){
// System.out.println("hellWorld");
// }
// while (true){
// System.out.println("hellWorld");
// }
do {
System.out.println("hello");
}while (true);
}
}
循环嵌套
package cn.bwl.xunhuan;
public class XunHuanQianTaoDemo7 {
public static void main(String[] args) {
//for可以嵌套while,do while 三者互相嵌套
for (int i = 0; i < 4; i++) {
for (int i1 = 0; i1 < 5; i1++) {
System.out.println("HelloWorld"+ i);
}
System.out.println("------------------");
}
//案例
//打印
//****
//****
//****
for (int i = 1; i <= 3; i++) {//外层循环控制有几行
for (int i1 = 1; i1 <= 4; i1++) {//内层循环控制每行打几列
System.out.print("*");
}
//每一行打完之后进行换行
System.out.println();
}
}
}
3.break continue
package cn.bwl.tiaozhuan;
public class BreakAndContinue {
public static void main(String[] args) {
//break 只能在循环中使用,跳出当前的循环
for (int i = 1; i <= 5; i++) {
System.out.println("我爱你" + i);
if (i == 3){
break;
}
}
//continue 只能在循环中使用,结束当前循环进入下一循环
for (int i = 1; i <= 5; i++) {
if (i == 3){
continue;
}
System.out.println("Hello" + i);
}
}
}
4.随机数 random
package cn.bwl.suijishu;
import java.util.Random;
public class RandomDemo1 {
public static void main(String[] args) {
Random r = new Random();
for (int i =1; i <= 14; i++) {
int re = r.nextInt(10);//产生0~9的随机数,括号里要写10
System.out.println(re);
}
System.out.println("-----------------");
//减加法 求随机数的范围表示1~10
//(1~10)-1 -> 0~9
// int re2 = r.nextInt(10+1);
for (int j = 1; j <= 20 ;j++) {
int re2 = r.nextInt(10) + 1;
System.out.println(re2);
}
System.out.println("-----------------");
//表示3~18的随机数20个
//3~18 -3 -> 0~15
for (int k =1; k <=20; k++) {
int re3 = r.nextInt(16) + 1;
System.out.println(re3);
}
}
}
小游戏
package cn.bwl.suijishu;
import java.util.Random;
import java.util.Scanner;
public class RandomTest2 {
public static void main(String[] args) {
//1.产生一个随1~100机数
Random r = new Random();
int rannum = r.nextInt(100) + 1;
//2.哦用户输入一个数,用死循环,直到猜到为止
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("请你输入一个数字:");
int guessnum = sc.nextInt();
//3,比较用户输入的字与随机数的大小
if (guessnum > rannum){
System.out.println("您输入的数字过大");
} else if (guessnum < rannum){
System.out.println("您输入的数字过小");
} else {
System.out.println("恭喜你猜中了数字,去买单");
break;
}
}
}
}
七、数组
1.数组的定义
一种容器,同种数据类型的多个值
2.数组的初始化
初始化,就是在内存中,为数组容器开辟空间,并将数据存入容器中的过程
静态初始化数组
package cn.bwl.array;
public class Demo1 {
public static void main(String[] args) {
//静态初始化数组
//数据类型[] 数组名 = new 数据类型[]{元素一,元素二,};
int[] age = new int[]{22, 47, 48};
double[] weight = new double[]{32.4, 54.4, 49.5, 93.4};
//简写
//数据类型[] 数组名 = {元素一,元素二,};
int[] a = {93, 49, 94, 93, 30};
}
}
直接打印数组名出现的是,地址值,而不知数组中的值
数组的地址值,表示数组在内存中的位置
package cn.bwl.array;
public class Demo1 {
public static void main(String[] args) {
//静态初始化数组
//数据类型[] 数组名 = new 数据类型[]{元素一,元素二,};
int[] age = new int[]{22, 47, 48};
double[] weight = new double[]{32.4, 54.4, 49.5, 93.4};
//简写
//数据类型[] 数组名 = {元素一,元素二,};
int[] a = {93, 49, 94, 93, 30};
//也可定义为
// 数据类型 数组名[] = {元素1,元素2,元素3,...};
byte b[] = {23,89,39};
//数组名可以找到数组首地址,引用数据类型
System.out.println(age);//[I@1b6d3586
System.out.println(weight);//[D@4554617c
System.out.println(a);//[I@74a14482
System.out.println(b);//[B@1540e19d
//地址值
//【 代表数组
//I 代表数据类型 I 整形 D 浮点类型
//@ 间隔符号
//1b6d3586 真正的地址值 16进制
//通常把整体称作地址值,但是真正的地址是数字
}
}
3.数组元素访问
package cn.bwl.array;
public class Demo2 {
public static void main(String[] args) {
//数组元素访问的应用
//1.获取 获取数组中的元素
//格式:数组名【索引】
//定义数组
int[] arr = {1 , 2 ,3 ,4 ,5};
//获取到的元素要放到变量中
int result = arr[0];
System.out.println(result);
//2.存储 往数组中存储数据
//格式:数组名【索引】= 具体数据 / 变量;
arr[0] = 100;
System.out.println(arr[0]);
}
}
数组名 [索引]
索引,又叫下标,角标
4.数组元素的遍历
1.定义
不要简单的认为是打印,而是取出数据的过程,
利用循环,结束条件为arr.length
package cn.bwl.array;
public class Demo3 {
public static void main(String[] args) {
//数组的遍历
//定义一个数组
int[] arr = {1,2,3,4,5};
//输出数组中的元素
//格式:数组名[索引]
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println("-------------------");
//重复进行一件事,利用循环
for (int i = 0; i < 5; i++) {
System.out.println(arr[i]);
}
System.out.println("-------------------");
//当数组内元素个数未知时,此时,循环的结束条件很难求
//求得,此时需要用 数组名.length 求数组长度(arr.length.fori)
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
2.数组求和
package cn.bwl.array;
public class Demo4 {
public static void main(String[] args) {
/*定义一个数组,存储1,2,3,4,5
遍历数组中每一个元素的值,并求数组中每一个数据的和*/
//定义数组
int[] arr = {1,2,3,4,5};
//定义sum总数
int sum = 0;
//遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
sum += arr[i];
}
System.out.println(sum);
}
}
3.数组中能被3整除的个数
package cn.bwl.array;
public class Demo5 {
public static void main(String[] args) {
/*定义一个数组,1,2,3,4,5,6,7,8,9,10
遍历数组,求出能被三整除的元素的个数
*/
//定义数组
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//遍历数组,判断能否被3整除,
//定义自增变量i
int i = 0 ;
for (int j = 0; j < arr.length; j++) {
if (arr[j] % 3 == 0){
// System.out.println(arr[j]);
i++;
}
}
System.out.println(i);
}
}
4.遍历的过程中去修改里面的数据
package cn.bwl.array;
public class Practice3 {
public static void main(String[] args) {
/*定义一个数组,1,2,3,4,5,6,7,8,9,10
遍历数组
要求:
当前数字为奇数,扩大为二倍
为偶数,缩小为二分之一
*/
//定义数组
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//遍历数组,判断奇偶数
for (int i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 0) {
arr[i] = arr[i] / 2;
} else {
arr[i] = arr[i] * 2;
}
}
//尽量一个循环只干一件事情,所以重新定义一个循环输出数组元素
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
5.数组动态初始化
直接指定数组的长度,由虚拟机给定默认的初始化值(知道元素个数)
与静态初始化不同的是
静态初始化已经知道数组的元素,自动计算出数组的个数(知道元素值)
package cn.bwl.array;
public class Demo4 {
public static void main(String[] args) {
//动态初始化数组(暂时不知道数组里面的元素,先给出数组的长度)
//格式:数据类型[] 数组名 = new 数据类型[数组长度];
//特点:在创建的时候,由我们给定数组的长度,由虚拟机给出默认的初始化值
//创建
String[] arr = new String[50];
//添加
arr[0] = "zhangsan";
arr[1] = "lisi";
//获取
System.out.println(arr[0]);//zhangsan
System.out.println(arr[1]);//lisi
System.out.println(arr[2]);//输出默认初始化的值null
//数据初始化默认值规律
//类型 默认值
//整形 0
//小数 0.0
//字符 '\u0000'也就是 空格
//布尔 false
//引用 null
//引用数据类型就是除八种数据类型之外的类型,这里是string
int[] arr1 = new int[3];
System.out.println(arr1[0]);//0
System.out.println(arr1[1]);//0
System.out.println(arr1[2]);//0
}
}
6.注意
数组访问越界
7.应用
1.求最值
package cn.bwl.array;
public class Practice4 {
public static void main(String[] args) {
//求数组中最大值 {22,7,19,33 ,49}
//1.创建数组,知道元素,静态初始化数组
int[] arr = {22,7,19,33,49};
//2.定义最大值,只要数组中的元素即可
int max = arr[0];
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
//i 索引 arr[i]元素
if (arr[i] > arr[0]) { //当元素值大于先定义的最大值时,更新最大值
max = arr[i];
}
}
//4.输出最大值
System.out.println(max);
//注意:
//1.可以根据最大值求最小值
//将涵义 max 改为 min, > 改为 <
//2.定义的最大值不能为0,因为 若数组中的元素都为负数,此时最大值将是0,不再为数组中的元素
//所以,最大值是数组中的任意一个元素均可,最好是arr[0],因为便于后面代码的修改
//3.当for (int i = 0; i < arr.length; i++),循环中arr[0]与arr[0]多比较了一次
//为提高效率,改为int i = 1
}
}
2.求和并统计个数
package cn.bwl.array;
import java.util.Random;
public class Practice5 {
public static void main(String[] args) {
//在1~100之间生成10个随机数,并求出有多少个比平均数小的值
//思路
//1.先求10个随机数的和
//2.求出10个数的平均数
//3.再求有多少个比平均数小的值
//1.定义数组,动态初始化,因为只知道元素个数
int[] arr = new int[10];
//2.定义随机数
Random r = new Random();
//3.遍历数组求随机数
int num;
for (int i = 0; i < arr.length; i++) {
//定义变量存随机数
num = r.nextInt(100)+1;//bound的范围是0~99,所以要加1
//****要把随机数添加到数组当中
arr[i] = num;
}
//4.求10个随机数的和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+= arr[i];
}
System.out.println("10个随机数的和为"+sum);
//5.求出10个数的平均数
int avg;
avg = sum / 10;
System.out.println("10个随机数的平均值为"+avg);
//6.求有多少个比平均数小的值
int count =0;//计数
for (int i = 0; i < arr.length; i++) {
if(arr[i] < avg){
count++;
}
}
System.out.println("10个随机数中有"+count+"个数比平均值小");
//验证
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
3.交换数组中的元素
package cn.bwl.array;
public class Practice6 {
public static void main(String[] args) {
//交换数组数据
//定义一个数组,存入1,2,3,4,5,
//交换前:1,2,3,4,5
//交换后:5,4,3,2,1
//1.先交换两个变量的值
int a = 10;
int b = 10;
//临时变量temp
int temp = a;
a = b;
b = temp;
System.out.println(a);
System.out.println(b);
//2.交换数组中最小索引和最大索引的的值
//定义数组
int[] arr = {1,2,3,4,5};
int temp2 = arr[0];
arr[0] = arr[4];
arr[4] = temp2;
System.out.println(arr[0]);
System.out.println(arr[4]);
System.out.println("------------");
//3.交换数组数据,用到两个变量指向最小索引和最大索引
//定义
int[] arr1 = {1,2,3,4,5};
//遍历交换
for (int i = 0, j = arr1.length - 1; i < j; i++, j--) {
int temp3 = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp3;
}
//遍历输出
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i]+" ");
}
}
}
4.打乱数组中的值
package cn.bwl.array;
import java.util.Random;
public class Practice7 {
public static void main(String[] args) {
//定义一个数组存入1,2,3,4,5,
//要求打乱数组中所有元素
//难点:
/*int[] arr = {1,2,3,4,5};
//获取随机索引
Random r = new Random();
int randomindex = r.nextInt();*/
//1.定义数组
int[] arr = {1,2,3,4,5};
//获取随机索引
Random r = new Random();
//2.遍历数组
for (int i = 0; i < arr.length; i++) {
//生成一个随机索引
int randomIndex = r.nextInt(arr.length);
//int randomIndex = r.nextInt(5);
int temp = arr[i];
arr[i] = arr[randomIndex];
arr[randomIndex] = temp;
}
//3.遍历输出数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
8.数组的内存图
new 出来的就是在堆里开辟了一个小空间
new的多次就是开辟了不同的小空间