注⚠️⚠️⚠️：本系列java笔记为个人学习过程中笔记记录，分享给各位小伙伴，希望能对各位小伙伴有所帮助。在参考笔记时，可根据自己的学习进程选取参考哦。此外，对于笔记中一些个人当时的学习理解，如有不妥欢迎各位小伙伴指正哦～
笔记内容多数是学习java语言时看的一些网课所记录，主要参考的是B站黑马程序员java课程。
目录
一.基础知识
1.程序框架
package basic;
public class HelloWorld {
public static void main(String[] args){
//System.out.println("Hello World!");
}
}2.标识符
-
标识符:给类、方法，变量等起的名字
1.由数字、字母、下划线(_)和美元符($)组成；
2.区分大小写；
3.不能以数字开头；
4.不能是关键字；
见名知意
方法、变量命名：
-
标识符是一个单词的时候，全部小写
-
标识符有多个单词组成时，第一个单词首字母小写，其他单词首字母大写
类命名：
-
标识符是一个单词的时候，首字母大写
-
标识符有多个单词组成时，每个单词首字母大写
-
-
Scanner(java包含的一个类，键盘录入)
-
导包---Scanner所处的类
import java.util.Scanner; //导包动作必须出现在类定义的上边 -
创建对象---使用Scanner
Scanner sc = new Scanner(System in); //以上仅sc为变量名可以改变，其余不可改变
-
接受数据---Scanner发挥作用
int i = sc.nextInt(); //以上格式仅i是变量名，可以改变，其余不可改变
-
package basic;
//导包---Scanner所处的类
//导包动作必须出现在类定义的上边
import java.util.Scanner;
public class Scan {
public static void main(String[] args){
//创建对象---使用Scanner
Scanner sc = new Scanner(System.in);
//接受数据---Scanner发挥作用
//变量 i 记录了键盘录入的数据
System.out.println("请输入第一个数字：");
int i = sc.nextInt();
System.out.println("请输入第二个数字:");
int j = sc.nextInt();
//System.out.println();
System.out.println(i+j);
}
}3.关键字
关键字：被赋予特定涵义的英文单词，小写
| 关键字 | 涵义 |
|---|---|
| class | 用于创建/定义一个类 |
类：java中最基本的组成单元
4.字面量
| 字面量类型 | 说明 | 范围 |
|---|---|---|
| 整数类型 | 不带小数点的数字 | |
| 小数类型 | 带小数点的类型 | |
| 字符串类型 | 用双引号括起来 | |
| 字符类型 | 用单引号括起来，内容只有一个 | |
| 布尔类型 | 布尔值，表示真（1）假（0） | |
| 空类型 | 一个特殊的值，空值 |
5.基本数据类型
-
整型
关键字 取值范围 内存占用 byte -128～127 1 short -32768~32767 2 int【默认】 +-e10 4 long +-e19 8 long类型在进行定义的时候需要在数据值后加上l/L作为后缀，建议使用L避免与数字1混淆
-
浮点型
关键字 取值范围 内存占用 float -3.40128e-38~3.40128e+38 4 double【默认】 -4.9000000e-324~1.797693e+308 8 float类型在进行定义时需加f/F作为后缀
-
字符型(char; 0~65535; 2字节)
-
布尔(boolean; true, false; 1字节)
6.运算符
(1)算数运算符
| 符号 | 作用 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 取余 |
| ++ | 自增 |
| -- | 自减 |
| = | 赋值 |
| += | 加后赋值 |
| -= | 减后赋值 |
| *= | 乘后赋值 |
| /= | 除后赋值 |
| %= | 取余后赋值 |
整数参与计算，结果得到整数；想要得到小数，必须有浮点数参与运算
小数参与计算，结果有可能是不精确的
/取结果的商，%取结果的余数
a%=b,即a➗b的余数赋值给a
-
隐式类型转换：取值范围小的数值-->取值范围大的数值
隐式类型转换是自动类型提升：
取值范围小的，和取值范围大的进行运算，小的会先提升为大的再进行计算【 byte --> short --> int --> long --> float -->double 】
byte short char三种类型的数据结构在运算的时候，都会直接先提升为int ，再进行计算。
数据类型不一样，不能进行计算，需要转换成一样的才可以进行计算
-
强制类型转换：取值范围大的数值-->取值范围小的数值
强制类型转换：将取值范围大的数值，赋值给取值范围小的变量是不允许直接进行的
格式：目标数据类型 变量名 = （目标数据类型）被强制转换的数据；
package basic;
public class count{
public static void main(String[] args){
byte b1 = 10;
byte b2 = 20;
byte result = (byte)(b1 + b2);
System.out.println(result);//20
}
}
package basic;
public class count{
public static void main(String[] args){
byte b1 = 100;
byte b2 = 200;
byte result = (byte)(b1 + b2);
System.out.println(result);//结果发生错误，超出byte范围
}
}关于'+'
当字符➕字符；字符➕数字时会把字符通过ASCII码表查询到对应的数字再进行计算【A==65; a=97】
当“➕”操作中出现字符串时，这个“➕”是字符串链接符，而不是算数运算符。会将前后的数据进行拼接，并产生一个新的字符串。【eg:"abc" + 123 --> "123123"】
连续进行“➕”操作时，从左到右逐个执行。【eg: 1 + 99 +"年牛马" --> "100年牛马"】
package basic;
public class count{
public static void main(String[] args){
System.out.println(3.7 + "abc");//"3.7abc"
System.out.println("abc" + true);//"abctrue"
System.out.println('中' + "abc" + true);//"中abctrue"
int age = 18;
System.out.println("我的年龄是" + age + "岁");//"我的年龄是18岁"
System.out.println("我的年龄是" + "age" + "岁");//"我的年龄是age岁"
System.out.println(1 + 2 + "abc" + 2 + 1);//"3abc21"
int a = 18;
int b = 20;
a += b;
System.out.println(a);
System.out.println(b);
short s = 1;
s += 1;
//等同于：s = s + 1; but,short-->int
//因此，此处存在强制类型转换：s = (short)(s + 1);
//+=,-=,/=,%=的底层都隐藏一个强制类型转换
System.out.println(s);
}
}+=,-=,/=,%=的底层都隐藏一个强制类型转换
(2)关系运算符
| 符号 | 作用 |
|---|---|
| == | a==b，判断a和b的值是否相等，成立为true，不成立为false |
| != | a!=b，判断a和b的值是否不相等，成立为true，不成立为false |
| > | a>b，判断a是否大于b，成立为true，不成立为false |
| >= | a>=b，判断a是否大于等于b，成立为true，不成立为false |
| < | a<b，判断a是否小于b，成立为true，不成立为false |
| <= | a<=b，判断a是否小于等于b，成立为true，不成立为false |
关系运算符的结果都是boolean类型，仅true、false
(3)逻辑运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑与 | 并且，两边都为真，结果才为真 |
| ｜ | 逻辑或 | 或者，两边都为假，结果才为假 |
| ^ | 逻辑异或 | 相同为false，不同为ture |
| ！ | 逻辑非 | 取反 |
| && | 短路与 | 结果和&相同，但有短路效果 |
| || | 短路或 | 结果和｜相同，但有短路效果 |
对于短路逻辑运算符，当左边的表达式能确定最终的结果，那么右边的表达式就不会参与运行了
package basic;
import java.util.Scanner;
public class judge {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要判断的次数：");
int num = sc.nextInt();
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//ture
System.out.println(false | true);//ture
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//ture
System.out.println(false ^ true);//ture
System.out.println(!true);//false
System.out.println(!false);//ture
System.out.println(true && true);//true
System.out.println(false && false);//false
System.out.println(true && false);//false
System.out.println(false && true);//false
System.out.println(true || true);//true
System.out.println(false || false);//false
System.out.println(true || false);//ture
System.out.println(false || true);//ture
//关于短路运算符
int a = 10;
int b = 10;
boolean result = ++a < 5 && ++b < 5;
System.out.println(result);//false
System.out.println(a);//11,++a参与运算
System.out.println(b);//10，//&&前运算符判断出结果为false,&&后的++b没有参与运算
b++;
result = ++a < 5 & ++b < 5;
System.out.println(result);//false
System.out.println(a);//12,++a参与运算
System.out.println(b);//12，//&&前运算符判断出结果为false,&&后的++b依旧78参与运算
}
}(4)三元运算符
格式：关系表达式 ？ 表达式1 ： 表达式2；
作用：可以进行判断，根据判断的结果得到不同的内容
计算规则：
首先计算关系表达式的值
如果值为true, 表达式1的值就是运算结果；
如果值为false, 表达式2的值就是运算结果；
(5)运算符的优先级
| 优先级 | 运算符 |
|---|---|
| 1 | .(){} |
| 2 | !、-、++、-- |
| 3 | *、/、% |
| 4 | +、- |
| 5 | <<、>>、>>> |
| 6 | <、<=、>、>=、instances |
| 7 | ==、!= |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ?: |
| 14 | =、+=、-=、*=、/=、%=、&= |
7.流程控制语句
(1)顺序结构
略
(2)分支结构
a.if语句
-
格式
//格式一:单条件判断 if (关系表达式){ 语句体； } //格式二：双条件判断 if(关系表达式){ 语句体1; }else{ 语句体2; } //格式三：多条件判断 if(关系表达式1){ 语句体1; }else if(关系表达式2){ 语句体2; } .... else{ 语句体n + 1; }执行流程：
1.首先计算关系表达式的值
2.如果关系表达式的值为true就执行语句体，否则不执行语句体/执行else if/else语句
3.继续执行后续语句
-
考试成绩
package basic; import java.util.Scanner; public class ConditionOne { public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入小明的成绩："); int score = sc.nextInt(); if(score >= 0 && score <= 100){ if(score >= 95 && score <= 100){ System.out.println("送自行车一辆"); }else if(score >= 90 && score <= 94){ System.out.println("游乐场玩一天"); }else if(score >= 80 && score <= 89){ System.out.println("送变形金刚一个"); }else if(score <80){ System.out.println("揍一顿"); } }else{ System.out.println("当前输入的成绩不合法"); } } } -
会员支付
package basic; import java.util.Scanner; public class ConditionOne { public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("商品的的价格为："); int price = sc.nextInt(); System.out.println("请输入会员的级别："); int vip = sc.nextInt(); if(vip == 1){ System.out.println("实际支付的钱为：" + (price * 0.9)); }else if(vip == 2){ System.out.println("实际支付的钱为：" + (price * 0.8)); }else if(vip == 3){ System.out.println("实际支付的钱为：" + (price * 0.7)); }else{ System.out.println("实际支付的钱为：" + price); } } }
b.switch语句
-
格式
switch(表达式){ case 值1: 语句体1; break; case 值2: 语句体2; break; .... default: 语句体n+1; break; } 格式说明： 1.表达式：(将要匹配的值)取值为byte、short、int、char【JDK5以后可以是枚举，JDK7以后可以是String】 2.case：后面跟的是要和表达式进行比较的值（被匹配的值） 3.break:表示中段，结束的意思，用来结束switch 4.default:表示所有情况都不匹配的时候，就执行该处的内容 5.case后面的值只能是字面量，不能是变量，且case后面给出的值不能重复执行流程：
1.首先计算表达式的值
2.依次和case后面的值进行比较，如果有对应的值就会执行相应的语句，在执行过程中遇到break就会结束
3.如果所有的case后面的值和表达式都不匹配，就会执行default里面的语句体，然后结束整个switch语句
-
吃面点单
package basic; import java.util.Scanner; public class ConditionTwo { public static void main(String[] ars){ Scanner sc = new Scanner(System.in); System.out.println("请输入您要吃的面："); String noodles = sc.nextLine(); switch (noodles){ case"兰州拉面": System.out.println("吃兰州拉面"); break; case"武汉热干面": System.out.println("吃武汉热干面"); break; case"北京炸酱面": System.out.println("吃北京炸酱面"); break; case"陕西油泼面": System.out.println("吃陕西油泼面"); break; default : System.out.println("吃方便面"); break; } } } -
运动计划
package basic; import java.util.Scanner; public class ConditionTwo { public static void main(String[] ars){ Scanner sc = new Scanner(System.in); System.out.println("请录入星期："); int week = sc.nextInt(); switch (week){ 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; } } }switch扩展：
1.default 可以省略不写（如果没有备选项的话），也可以在整个语句的其他位置，不一定在下面，但习惯上将它放在最后面
2.case穿透：通过break控制，遇到break才会中断，否则继续向下运行【一般在多个case语句体重复时使用】
3.switch特性+1【JDK12之后可使用】：简化代码
4.if与switch比较：if一般用于对范围的判断；switch一般用于把有限个数据一一列举出来，从中任选其一
-
运动计划的拓展
package basic; import java.util.Scanner; public class ConditionTwo { public static void main(String[] ars){ Scanner sc = new Scanner(System.in); System.out.println("请录入星期："); int week = sc.nextInt(); switch (week){ case 1 ->{ System.out.println("跑步"); } case 2 ->{ System.out.println("游泳"); } case 3 ->{ System.out.println("慢跑"); } case 4 ->{ System.out.println("动感单车"); } case 5 ->{ System.out.println("拳击"); } case 6 ->{ System.out.println("爬山"); } case 7 ->{ System.out.println("吃顿好的"); } default ->{ System.out.println("吃顿好的"); } } } } //case后大括号只有一条语句，大括号也可以省去 package basic; import java.util.Scanner; public class ConditionTwo { public static void main(String[] ars){ Scanner sc = new Scanner(System.in); System.out.println("请录入星期："); int week = sc.nextInt(); switch (week){ case 1 -> System.out.println("跑步"); case 2 -> System.out.println("游泳"); case 3 -> System.out.println("慢跑"); case 4 -> System.out.println("动感单车"); case 5 -> System.out.println("拳击"); case 6 -> System.out.println("爬山"); case 7 -> System.out.println("吃顿好的"); default -> System.out.println("吃顿好的"); } } } -
工作周
package basic; import java.util.Scanner; public class ConditionTwo { public static void main(String[] ars){ Scanner sc = new Scanner(System.in); System.out.println("请输入一个整数表示星期 "); int week = sc.nextInt(); switch (week){ case 1 : case 2 : case 3 : case 4 : case 5 : System.out.println("工作日"); break; case 6 : case 7 : System.out.println("休息日"); break; default : System.out.println("录入错误"); break; } } } //进一步化简 package basic; import java.util.Scanner; public class ConditionTwo { public static void main(String[] ars){ Scanner sc = new Scanner(System.in); System.out.println("请输入一个整数表示星期 "); int week = sc.nextInt(); switch(week){ case 1, 2, 3, 4, 5 : System.out.println("工作日"); break; case 6, 7 : System.out.println("休息日"); break; default : System.out.println("录入错误"); break; } } } -
机票业务
package basic; import java.util.Scanner; public class ConditionTwo { public static void main(String[] ars){ Scanner sc = new Scanner(System.in); System.out.println("请输入您的选择："); String noodles = sc.nextLine(); switch (noodles){ case "1" : System.out.println("机票查询"); break; case "2" : System.out.println("机票预订"); break; case "3" : System.out.println("机票改签"); break; case "4" : System.out.println("退出服务"); break; default : System.out.println("退出服务"); break; } } }
(3)循环结构
a.for循环
-
格式
for(初始化语句；条件判断语句；条件控制语句){ 循环体语句； }
执行流程：
1.执行初始化语句【作为循环的开始，仅执行一次】
2.执行条件判断语句，看其结果是true还是false，如果是ture执行循环体语句；如果是false，循环结束
3.执行条件控制语句
4.回到2继续执行条件判断语句
b.while循环
-
格式
初始化语句; while(条件判断语句){ 循环体语句; 条件控制语句; }
执行流程：
1.执行初始化语句【作为循环的开始，仅执行一次】//可位于循环外
2.执行条件判断语句，看其结果是true还是false，如果是ture执行循环体语句；如果是false，循环结束
3.回到2继续执行条件判断语句
for与while对比：
相同点：运行规则都是一样的
区别：
for循环中控制循环的变量归属于for循环的语法结构中，在for循环结束后，就不能再次被访问到。但当for循环的变量定义在循环体外时，脱离循环体也可以访问
while循环中，控制循环的变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
！！for循环：知道循环次数或者循环的范围；while循环：不知道循环的次数和范围，只知道循环的结束条件。
-
回文数
package basic; import java.util.Scanner; public class PalindromicNumber { public static void main(String[] args){ Scanner sc = new Scanner(System.in); //判断回文数，是打印ture;不是打false //核心思路：把数字到过来与原数字比较 //录入数字 System.out.println("请输入所需要判断的数字："); int x = sc.nextInt(); int num = 0; int temp = x; while(temp != 0){ //从右往左获取每一位数字 int ge = temp % 10; temp /= 10 ; num = num * 10 + ge; } System.out.println(num); System.out.println(num==x ? "ture" : "false"); } } -
循环中的除法
package basic; import java.util.Scanner; public class Divisor { public static void main(String[] args){ Scanner sc = new Scanner(System.in); /* 给定两个整数，除数和被除数（都是正整数，且不超过int范围） 将两数相除，要求不使用乘法、除法、取余运算符得到商和余数 */ //分析：被除数 / 除数 = 商 ... 余数 System.out.println("请输入被除数："); int dividend = sc.nextInt(); System.out.println("请输入除数："); int divisor = sc.nextInt(); int cnt = 0; while(dividend >= divisor){ dividend -= divisor; cnt ++; } System.out.println("商：" + cnt); System.out.println("余数：" + dividend); } }
c.do...while循环
-
格式
初始化语句 do{ 循环体语句; 条件控制语句; }while(条件判断语句);
d.循环扩展
-
无限循环
无限循环： //for循环 for(;;){ 循环体; } //while循环 while(ture){ 循环体; } //do...while循环 do{ 循环体; }while(ture); //无限循环下面不能写其他代码，循环不会停止，循环后代码不能得到执行
-
跳转控制语句
continue:跳出本层循环的本轮循环,继续执行本层循环的下一轮循环; break:跳出本层循环;
e.循环综合练习
-
逢七过
package basic; public class SevenPass { public static void main(String[] args){ for(int i = 1; i <= 100; i++){ if(i % 10 == 7 || i / 10 % 10 == 7 || i % 7 == 0){ System.out.println("过"); continue; }else{ System.out.println(i); } } } }
-
平方根
package basic; import java.util.Scanner; public class SquareRoot { public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入需要处理的数字："); int num = sc.nextInt(); for(int i = 0; i <= num; i++){ if(i * i == num){ System.out.println(i + "就是" + num + "的平方根"); break; }else if(i * i > num){ System.out.println((i-1) + "就是" + num + "平方根的整数部分"); break; } } } } -
求质数
package basic; import java.util.Scanner; public class PrimeNumber { public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入需要判断的数："); int num = sc.nextInt(); boolean flag = true; for(int i = 2; i < num/2; i += 1){ if(num % i == 0){ //System.out.println(num + "不是一个质数"); flag = false; break; } } System.out.println(num + (flag ? "是" : "不是") + "一个素数"); } } -
猜数字
//获取随机数 //导包 import java.util.random; //创建对象 Random r = new Random(); //以上仅r为变量名可以改变，其余不可改变 //random发挥作用 int number = r.nextInt(随机数的范围); //以上格式内，仅number为变量名，可以改变，其余均不可改变 int number = r.nextInt(a , b); //实际范围：[a,b)package basic; import java.util.Scanner; import java.util.Random; public class GuessNumber { public static void main(String[] args){ Scanner sc = new Scanner(System.in); Random r = new Random(); //生成一个随机数范围1～100 int num = r.nextInt(0,100) + 1; //扩展机制：保底3次猜中 int count = 0; while(true){ System.out.println("请输入你要猜的数："); int x = sc.nextInt(); count ++; if(x == num || count == 3){ System.out.println("恭喜您猜对了！"); break; }else if(x > num){ System.out.println("大了！"); }else{ System.out.println("小了！"); } } } }
二.数组
-
数组：可以用来存储多个同种数据类型的值
数组容器在存储数据的时候，需要结合隐式转换考虑
Eg:
int类型数组容器【boolean. byte. short. int. double.】
double类型数组容器【byte. short. int. long. float. Double】
1.数组相关概念
(1)数组的定义
//格式一
数据类型 [] 数组名 //eg: int [] array
//格式二
数据类型 数组名[] //eg: int array[](2)数组地址值
-
数组的地址值表示数组在内存中的位置
-
数组地址分析
举个栗子：地址：[D@776ec8df
[ :表示当前是一个数组
D :表示当前数组内元素为double 类型；【如果为int类型则为I】
776e8df : 数组真正的地址值以十六进制形式展现
-
索引：即下标，角标。索引从0开始，逐个+1增长，连续不间断
-
数组遍历：利用循环对数组内每个元素进行遍历
//开始条件：0 //结束条件L：数组长度 - 1(最大索引) //数组长度属性，length ;调用方式：数组名.length for(int i = 0;i < arr.length; i++){ System.out.println(arr[i]); } //idea中快速生成数组的遍历方式： 数组名.fori + 回车数组常见问题：索引越界异常，索引超出了数组范围
小建议：一个循环尽量做一件事情，方便整理思路
2.数组的初始化
(1)静态初始化
-
初始化：在内存中为数组容器开辟空间，并将数据存入容器过程中
-
完整格式：数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...};
-
简化格式：数据类型[] 数组名 = {元素1, 元素2, 元素3...};
-
Eg: int[] array = new int[]{11, 22, 33};
double[] array2 = new double[]{11.1, 22.2, 33.3};
(2)动态初始化
-
动态初始化时只指定数组长度，由系统为数组分配初始值
-
格式：数据类型[] 数组名 = new 数据类型[数组长度]
数组默认初始化值：
整数类型：默认初始化值为 0
小数类型：默认初始化值为 0.0
字符类型：默认初始化值为 '/u0000'
布尔类型：默认初始化值为 false
引用数据类型：默认初始化值为 null
3.数组常见操作
a.求最值
-
打擂台
int max = arr[0]; for(int i = 1; i < arr.length; i++){ if(arr[i] > max){ max = arr[i]; } }1.定义max变量准备记录擂台上的变化： int max = arr[0];
2.遍历数组获取每一个元素
让每一个元素与max进行比较，如果找到更大的，就使max记录该元素
b.求和
package basic;
import java.util.Random;
public class Sum {
public static void main(String[] args){
Random r = new Random();
//定义数组
int[] arr = new int[10];
//把随机数存到数组当中
for (int i = 0; i < arr.length; i++){
int number = r.nextInt(100) + 1;
//将生成的随机数添加到数组当中
//数组名[索引] = 数据；
arr[i] = number ;
}
//求和
int sum = 0;
for (int i = 0; i < arr.length; i++){
sum += arr[i];
}
System.out.println("数组中所有数据的和为：" + sum);
double avg = (double)sum / arr.length;
System.out.println("数组平均数为：" + avg);
int count = 0;
for(int i = 0; i < arr.length; i++){
if(arr[i] < avg){
count++;
}
}
System.out.println("在数组中，一共有" + count + "个数据比平均数小");
//遍历数组，验证答案
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + "\t");
}
}
}遍历数组，利用循环进行求和，取平均值，记录等操作
d.打乱数据
package basic;
import java.util.Random;
public class Disorganize {
public static void main(String[] args){
Random r = new Random();
//需求：定义一个数组，存入1～5，要求打乱数组中所有数据顺序
//获取随机索引
int[] arr = {1, 2, 3, 4, 5};
for(int i = 0; i < arr.length; i++){
int temp = arr[i];
int x = r.nextInt(arr.length);
arr[i] = arr[x];
arr[x] = temp;
}
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + "\t");
}
}
}
4.数组的内存图
(1)JAVA的内存分配
-
栈：方法运行时使用的内存，方法开始执行时进栈，执行完毕出栈
-
堆：存储对象或数组，new来创建的数据都存储在堆内存，在堆内存开辟空间并产生地址。
-
方法区：存储可以运行的class文件
-
寄存器：给CPU使用
-
本地方法栈 ：JVM在使用操作功能的时候使用
JDK7及之前方法区域堆相连，JDK8之后方法区一部分分给堆，一部分存储在新分离出的元空间
当两个数组指向同一个小空间时，其中一个数组对小空间的值发生了改变，那么其他数组再次访问的时候都是修改后的结果
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
