目录
0、编程思想—我亦无他，惟手熟尔
1.化繁为简
拆解步骤，循序渐进
例题：空心金字塔 && 空心菱形
1.打印一个矩形
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.print("*");
}
System.out.println();
}
*****
*****
*****
*****
*****
2.打印半个金字塔
for (int i = 0; i < 5; i++) {
for (int j = 0; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
*
**
***
****
*****
3.打印整个金字塔
/* n是金字塔总层数
层数 *数（2i-1） 空格数（n-i）
* 1 1 4
* 2 3 3
* 3 5 2
* 4 7 1
* 5 9 0
* */
System.out.println("请输入金字塔高度：");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
System.out.print("*");
}
System.out.println();
}
*
***
*****
*******
*********
2.先死后活
先写死，再换成变量
4.打印空心金字塔
// 通过观察可以发现除最后一行外，其余各行只有第一个和最后一个"*"存在，其余"*"均有" "代替
System.out.println("请输入金字塔高度：");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1 || i == n)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println();
}
*
* *
* *
* *
*********
5.打印空心菱形
//上下两个空心金字塔即可组成一个空心菱形
System.out.println("请输入高度：");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
// 上金字塔
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println();
}
// 下金字塔
for (int i = n-1; i >= 1; i--) {
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println();
}
一、java语言概述
1. java执行流程：
- 编写：源文件(.java);
- 编译：通过javac.exe命令将源文件编译成字节码(.class)文件；
- 运行：通过java.exe命令解释运行.class文件。
2.环境变量的作用
当我们在cmd命令行中执行一条命令时，经常会出现"xxx不是内部或外部命令，也不是可运行的程序或批处理文件。"此类提示。造成这种现象的原因是我们并没有在对应的目录下执行此命令，所以系统找不到此命令。但当我们配置环境变量之后，无论在哪个目录下，都可以执行此命令。
配置环境变量后，如果在当前目录下找不到此命令，则会去环境变量所配置的路径下寻找。
3.跨平台性
java源文件只需要编译一次，就可以在多个系统环境下运行（一次编译，到处运行）。
原理：java程序是通过jvm在系统平台上运行，在系统上安装相应的jvm，就可以运行编译好的字节码文件。
3.总结
- * 1.System.out.println换行
* 2.System.out.print 不换行
* 3.main就是一个静态方法，可以通过对象或类名调用，一般推荐使用类名调用，因为静态方法是属于类的，被本类中所有对象共享。
* 4. 每个.java源文件中只能有一个public类(可以没有),且此类与文件名相同.
* 5. 若一个.java源文件中有多个class类,则编译后会产生多个.class字节码文件.
二、Java 基本语法
1.标识符
凡是自己手动命名的地方都叫标识符
2.标识符的命名规则
必须遵守，否则编译不通过（相当于法律）
- 只能由数字、字母，下划线和$组成
- 不能以数字开头
3.标识符的命名规范
不遵守，编译可以通过，但建议遵守（相当于道德）
- 包：全部小写
- 类：每个单词的首字母大写
- 变量、方法：首单词的首字母小写，其余单词的首字母大写
- 常量：所有字母大写，相邻单词使用_连接
4.数据类型
4.1 基本数据类型
- 整型：byte，short，int，long
- 浮点型：float，double
- 字符型：char
- 布尔型：boolean
4.2 引用数据类型
- 类
- 接口
- 数组
4.3 自动类型转换
基本数据类型中除了boolean，其余都可以进行运算。
范围排序：byte、short、char -> int -> long -> float -> double
- byte、short、char三者进行运算时，结果都是int
- 范围小的数据类型与范围大的数据类型进行运算时，结果是范围大的数据类型
- 范围小的数据类型可以自动转换成范围大的数据类型，反之不行
- 被fianl修饰的变量不会自动改变类型，当2个final修饰变量相操作时，结果会根据等号左边变量的类型而转化，即等号左边的变量可以是任意基本数据类型。如果一个是final，一个不是，那么还是要进行自动类型转换。例题
4.4 强制类型转换
格式：（基本数据类型）表达式
- 将范围大的数据类型转换成范围小的数据类型，可能会损失精度。
- 整数常量默认是int类型，浮点型常量默认是double类型。
4.5 String
- String不是基本数据类型，是引用数据类型
- 可以与8种基本数据类型（boolean也可）进行连接运算，结果是String类型
- 转义字符使用单引号、双引号都可以
System.out.println('a'+'\t'+'b'); // char类型运算，结果是int类型 204
System.out.println('a'+"\t"+'b'); //a b
System.out.println('a' +'\t'+ "b"); //106b
System.out.println('a'+('\t'+"b")); //a b
- 字符串内容的比较使用方法equal()，推荐将常量放在前面，可以避免空指针异常；
// 登录验证
Scanner sc = new Scanner(System.in);
for (int i = 3; i > 0; i--) {
System.out.println("please input username:");
String username = sc.next();
System.out.println("please input password:");
String password = sc.next();
if ("123".equals(username) && "456".equals(password)) {
System.out.println("登陆成功");
break;
} else {
System.out.println("您还有" + (i - 1) + "次机会");
}
}
4.6 练习
short s = 5;
s = s-2; //判断：no；2是int类型，s-2结果是int类型，无法由int类型隐式转换成short类型，所有编译出错。
byte b = 3;
b = b + 4;//判断：no；与上面同理
b = (byte)(b+4);//判断：yes 强制类型转换
char c = ‘a’;
int i = 5;
float d = .314F;
double result = c+i+d; //判断：yes；float的范围最大，故运算结果是float类型的，float类型可以自动转换成double类型。
byte b = 5;
short s = 3;
short t = s + b;//判断：no；byte和short运算结果是int类型，int不能隐式转换成short类型，故编译出错。
5.运算符
5.0 %模运算
a是小数时，模运算的公式：a % b = a - (int) a / b * b
-10.5 % 3 = -1.5
5.1 &和&&的区别
&是逻辑与，第一个表达式无论真假，第二个表达式都会参与计算；
&&是短路与，如果第一个表达式为真，则第二个表达式参与计算，如果第一个表达式为假，则第二个表达式不再计算；
5.2 位运算符
- 其中&、|、^三者在逻辑运算符中也出现过，可以根据两侧表达式的类型来判断是逻辑运算符还是位运算符，如果两边是boolean类型的，则为逻辑运算符；如果两边是数值类型（不能是float和double）的，则为位运算符。
- 没有无符号左移。
5.3 异或实现两数交换
a = (a^b) ^ b
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;
5.4 练习
class OperatorTest {
public static void main(String[] args) {
boolean x = true;
boolean y = false;
short z = 40;
if ((z++ == 40) && (y = true)) { // y = true是赋值语句，先赋值再用y参与运算
z++;
}
if ((x = false) || (++z == 43)) {
z++;
}
System.out.println("z = " + z++);
}
}
z = 44
//比较三个数的大小
int a = 12, b = 22, c = 22;
// 方法一
int max = (a > b) ? ((a > c) ? a : c) : (b > c ? b : c);
// 方法二
if (a > b && a > c) {
System.out.println(a);
} else if (b > a && b > c) {
System.out.println(b);
} else {
System.out.println(c);
}
System.out.println(max);
6.Scanner读取键盘输入
Scanner中并没有提供直接获取char类型的方法，故可以先获取String类型，然后使用charAt(0）方法将其转为char类型
Scanner sc = new Scanner(System.in);
String name = sc.next();
int age = sc.nextInt();
double height = sc.nextDouble();
boolean b = sc.nextBoolean();
char c = sc.next().charAt(0);
7.获取随机数
// Math.random() 得到的数值范围[0,1)
// 输出10~99之间的整数
int random = (int)(Math.random()*90+10);
获取[a,b]之间的整数公式
int random = （int）(Math.random()*(b-a+1)+a)
8.分支结构
8.1 if-else
// 从大到小输出abc：一定要注意分类思想，先把简单的情况写出来，然后将复杂的情况写在else中。
if (a > b) {
if (c > a) {
System.out.println("" + c + a + b);
} else if (c < b) {
System.out.println("" + a + b + c);
} else {
System.out.println("" + a + c + b);
}
} else {
if (c > b) {
System.out.println("" + c + b + a);
} else if (c < a) {
System.out.println("" + b + a + c);
} else {
System.out.println("" + b + c + a);
}
}
if-else配对遵循就近原则
int a = 4,b= 5;
if(a>2)
if(b<3)
System.out.println(b);
else
System.out.println(a);
4
8.2 switch-case
- 流程图
- 穿透：如果语句块中没有break语句，那么不会验证是否满足下一个case，而是直接执行下一个语句块，直到遇到break或是switch代码结束为止。
- case后面是常量，不能是变量
- switch中的表达式的数据类型只能是：byte、short、char、int、enum、String[JDK7.0后]
- switch表达式中数据类型应与case后的常量类型一致，或者是可以自动转换的类型（只要两边能互相转换即可，范围大小没关系。如char和int，byte和char）
- break和default都是可选的
练习
//将小写字母转为大写字母
Scanner sc = new Scanner(System.in);
char c = sc.next().charAt(0);
switch(c){
case 'a':
System.out.println('A');
break;
case 'b':
System.out.println("B");
break;
case 'c':
System.out.println('C');
break;
default:
System.out.println("other");
}
// 大于60合格，小于60不合格
System.out.print("请输入：");
double score = sc.nextDouble();
switch((int)(score/60)){
case 1:
System.out.println("合格");
break;
case 0:
System.out.println("不合格");
break;
}
// 输入年月日，判断是该年的第几天
while (true){
System.out.print("please input year:");
int year = sc.nextInt();
System.out.print("please input month:");
int month = sc.nextInt();
System.out.print("please input day:");
int day = sc.nextInt();
int days = 0;
switch (month) {
case 12:
days += 30;
case 11:
days += 31;
case 10:
days += 30;
case 9:
days += 31;
case 8:
days += 31;
case 7:
days += 30;
case 6:
days += 31;
case 5:
days += 30;
case 4:
days += 31;
case 3:
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
days += 29;
else
days +=28;
case 2:
days+=31;
case 1:
days+=day;
System.out.println("第"+days+"天");
break;
default:
System.out.println("输入有误");
}
}
defalult放在前边，如果没有break，执行完后还会执行下边的语句
public static void main(String[] args){
show(0); 15
show(1); 14
}
public static void show(int i){
switch(i){
default:
i+=2;
case 1:
i+=1;
case 4:
i+=8;
case 2:
i+=4;
}
System.out.println("i="+i);
}
8.3 三元运算符
面试题System.out.println(true ? 1 : 2.0); 输出：1.0
如果后边是两个数值型变量，那么三元运算符结果的类型是范围大的那个
8.4 switch-case 和 if-else 选择
- 当判断的数值不多时，且数据类型是byte、short、char、int、enum、String这六种类型时，建议使用switch；
- 对区间判断和boolean类型的判断，建议使用if-else；
- 所有的switch语句和三元运算符都可以转换成if语句，反之则不一定；
- switch语句和三元运算符的执行效率相对高；
9.循环结构
9.1 for循环
- 对于在for中定义的初始化语句
int i= 0；其中i的作用域是for循环中；
for (int i = 0; i < 100; i++) {
if(i%2==0)
System.out.println(i);
}
9.2 for循环练习
break不要忘
练习1：最大公约数和最小公倍数
// 最大公约数和最小公倍数
Scanner sc = new Scanner(System.in);
System.out.println("please input m:");
int m = sc.nextInt();
System.out.println("please input n:");
int n = sc.nextInt();
int i = m > n ? n : m;
for (; i >= 1; i--) {
if (m % i == 0 && n % i == 0) {
break;
}
}
System.out.println("最大公约数：" + i);
// 最小公倍数可以使用公式求出，也可以用求最小公约数的方法求出
int j = m > n ? m : n;
for (; j <= m * n; j++) {
if(j%m==0&&j%n==0){
System.out.println("最小公倍数：" +j);
break;
}
}
System.out.println("最小公倍数：" + m * n / i);
每满n个换行，可以采用i%n==0进行判断
练习2：换行输出
int count = 0;
for (int i = 1; i <= 100; i++) {
if(i%5!=0){
System.out.print(i+"\t");
count++;
if(count%5==0){
System.out.println();
}
}
}
练习3：循环输出a-z
自增不会改变数据类型
for (char i = 'a'; i <= 'z'; i++) {
System.out.println(i);
}
练习4： 求解1-1/2+1/3-1/4+1/5-…-1/100
注意：在程序中整除的值是商，不留余数，所以常量要写成double类型的
double sum = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
sum -= (1.0 / i);
}else{
sum += (1.0 / i);
}
}
System.out.println(sum);
9.3 while和do-while的区别
- do-while至少执行一次，while可以一次也不执行；
- do-while最后有一个分号；
do {
循环体；
}while (循环条件);
9.4 嵌套循环
练习1：99乘法表
// 99乘法表
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + i * j + "\t");
}
System.out.println();
}
练习2：100以内的所有质数
// 方法1：100以内的所有质数（质数：只能被1和自身整除）
boolean flag;
for (int i = 2; i < 100; i++) {
flag = true;
for (int j = 2; j*j <= i; j++) {
if(i%j==0){
flag = false;
break;
}
}
if(flag){
System.out.println(i);
}
}
// 方法2：利用带标签的continue
lable:for (int i = 2; i < 100; i++) {
for (int j = 2; j*j <= i; j++) {
if(i%j==0){
continue lable;
}
}
System.out.println(i);
}
练习3：打印金字塔
// 打印金字塔
System.out.println("请输入金字塔高度：");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1 || i == n)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println();
}
练习4：打印空心菱形
//打印空心菱形：上下两个空心金字塔即可组成一个空心菱形
System.out.println("请输入高度：");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
// 上金字塔
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println();
}
// 下金字塔
for (int i = n-1; i >= 1; i--) {
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
if (j == 1 || j == 2 * i - 1)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println();
}
10.break、continue、return
| 关键字 | 作用 |
|---|---|
| break | 跳出本层循环，可用于switch和循环 |
| continue | 跳出本次循环，只能用于循环 |
| return | 结束当前方法 |
10.1 带标签的break和continue
可以跳出多层循环
ok:for (int i = 0; i < 100; i++) {
ok1: for (int j = 0; j < 100; j++) {
if(i*j==2){
break ok;
continue ok; // 作用相当于break;
}
}
}
11.项目一：家庭记账系统
while(flag)while的循环条件可以设置一个变量，在循环中通过改变变量值达到退出循环的目的；(系统退出功能模块)
12.一维数组（引用数据类型）
12.1 快速入门
int[] array = {1,2,3,4};// 定义一个一维数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]); // 遍历数组元素，其中array.length表示数组的长度，array[i]表示数组中的i个元素
}
12.2 数组的四种定义方式
int[ ] array 和 int array[ ] 是等价的，四种定义方式都会在堆中开辟一块新空间;
静态初始化：定义数组时给各元素赋值；
动态初始化：定义数组时不进行赋值；
方式1：动态初始化
int array[] = new int[5];
方式2：先声明，在new分配空间
int[] array;
array = new int[5];
方式3：静态初始化
int[] array = {1,2,3,4,5};
方式4：静态初始化
int[] array = new int[]{1,2,3,4,5};
12.3 数组特点
- 数组中元素的数据类型可以是基本数据类型和引用数据类型，但是同一数组中元素的数据类型必须是一致的；
- 数组定义后不赋值会有默认值，int、short、byte、long默认为0，float、double默认为0.0，boolean默认为false，char默认为\u0000（整数0的ASCII码），String默认为null（引用数据类型的默认值为null）；
- 数组的长度一旦确定，就不能修改；
- 数字名指向数组首个元素的地址；
- 可以通过数组名将此数组地址赋给另一个数组，不用考虑数组的长度；但是类型相同才能赋值，二维数组不能赋值给一维数组
- 如果求平均值，应该令总和为double类型；
12.4 值传递和引用传递
- 基本数据类型之间赋值是进行值传递，变量之间是相互独立的；
- 引用数据类型之间赋值进行的是地址传递，变量共享同一块堆空间（相当于给文件创建了快捷方式）；
12.5 数组拷贝
- 如果是使用
arr1[i] = arr2[j]的方式给数组赋值，那么这是值传递，两个数组之间互相独立；
数组反转：新创建一个数组，将原数组的值挨个赋值给新数组，最后将新数组的地址赋值给原数组
int[] arr = {1, 2, 3, 4, 5, 6, 7};
int[] arr2 = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
arr2[i] = arr[arr.length-1-i];
}
arr = arr2;
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
12.6 内存解析
- 局部变量：定义在方法中的变量都是局部变量，局部变量都在栈中；
引用数据类型的变量值只可能时null或者地址值，”Tom“在常量池中，而strs[2]中存放的是其地址。
13.排序
13.1 冒泡排序
int[] arr = {2, 1, 4, 5, 6, 3, 14, 8, 32};
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]) {
swap(arr, j);
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
private static void swap(int[] arr, int j) {
arr[j] = arr[j] ^ arr[j + 1];
arr[j + 1] = arr[j] ^ arr[j + 1];
arr[j] = arr[j] ^ arr[j + 1];
}
14.二维数组
定义：数组中的元素类型是一维数组类型的，那此数组就是二维数组。
14.1 快速入门
int[][] arr = {{1,2,3,4,5},
{6,7,8,9,10},
{1,2,3,4,5}}; // 声明并初始化二维数组
// 遍历二维数组，数组名[i][j]访问数组中元素
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
14.2 二维数组的定义方式
int[ ][ ] arr、int arr[ ][ ] 、int[ ] arr[ ] 三者等价
- 动态初始化
方式1：int[][] arr = new int[3][4];
方式2；int[][] arr1;
arr1 = new int[3][4];
一维数组中的元素个数不同
方式3：一维数组中的元素个数不同
// 初始化二维数组，但每个一维数组还没有开数据空间，此时一维数组的值为null
int[][] arr = new int[3][];
for (int i = 0; i < arr.length; i++) {
arr[i] = new int[i+1]; // 给每个一维数组开辟内存空间
for (int j = 0; j < arr[i].length; j++) {
arr[i][j]=i+1; // 给一维数组中的每个元素赋值
}
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]+"\t"); // 输出每个一维数组
}
System.out.println();
}
1
2 2
3 3 3
- 静态初始化
int[][] arr1 = {{1,2},{3},{4,5,6}};
int[][] arr2;
arr2 = new int[][]{{1,2},{3},{4,5,6}};✔
arr2 = {{1,2},{3},{4,5,6}}；❌（一维数组同理）
14.3 二维数组的特点
- 二维数组的每个元素是一维数组；
- 二维数组长度：数组名.length；
- 二维数组中每个一维数组元素的个数可以不同；
- 二维数组定义时，列数可以不指定，但行数必须指定；
14.4 二维数组内存布局
arr[i]中存放的时一维数组的地址值；
14.5 二维数组的默认值
* ⑤ 数组元素的默认初始化值
* 针对于初始化方式一：比如：int[][] arr = new int[4][3];
* 外层元素的初始化值为：地址值
* 内层元素的初始化值为：与一维数组初始化情况相同
*
* 针对于初始化方式而：比如：int[][] arr = new int[4][];
* 外层元素的初始化值为：null
* 内层元素的初始化值为：不能调用，否则报错。
*
int[][] arr = new int[4][3];
System.out.println(arr[0]); //[I@15db9742
System.out.println(arr[0][0]); //0
// System.out.println(arr); //ArrayTest3.java
System.out.println("***********************");
float[][] arr1 = new float[4][3];
System.out.println(arr1[0]); //地址值
System.out.println(arr1[0][0]); //0.0
System.out.println("***********************");
String[][] arr2 = new String[4][2];
System.out.println(arr2[1]); //地址值
System.out.println(arr2[1][1]); //null
System.out.println("*********************");
double[][] arr3 = new double[4][];
System.out.println(arr3[1]); //null
// System.out.println(arr3[1][0]); //报错
14.6 练习–杨辉三角
使用二维数组打印杨辉三角
int[][] arr = new int[10][];
for (int i = 0; i < arr.length; i++) {
arr[i] = new int[i + 1];
for (int j = 0; j < arr[i].length; j++) {
if (j == 0 || j == arr[i].length - 1)
arr[i][j] = 1;
else {
arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1]; // 杨辉三角的规律
}
}
}
// 输出
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
14.7 练习–数组的定义
f：对于引用数据类型来说，类型相同才能赋值
并对错误的答案加上单行注释，写出错误的原因。
A，float[]=new float[3]; // 没有数组名
B, float f2[]=new float[];//没有定义数组长度
C, float[] f1=new float[3];//
D, boolean[] b={"true","false","true"};// boolean不是字符串
E, double f4[]={1,3,5}; //
F, int f5[]=new int[3]{2,3,4}; // 动态初始化和静态初始化不能同时出现
G, float f4[]={1.2F,3.0,5.4};// 3.0，5.4是double类型的，不能自动转为float
14.8 练习–归并排序思想
题目：向升序数组中插入一个元素，使其仍保持升序
思路：归并排序，把要插入的数当作长度为1的数组。
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[]{10, 12, 45, 90};
int[] temp = new int[arr.length + 1];
int i;
for (i = 0; i < arr.length; i++) {
if (arr[i] < n) {
temp[i] = arr[i];
} else {
temp[i] = n;
break;
}
}
if (i == arr.length) {
temp[temp.length-1] = n;
} else {
while (i < arr.length) {
temp[i + 1] = arr[i];
i++;
}
}
for (int j = 0; j < temp.length; j++) {
System.out.print(temp[j]+"\t");
}
14.9 练习–数组元素的赋值
创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同
i--的思想一定要掌握
int[] arr = new int[6];
for (int i = 0; i < arr.length;i++) {
// 不管是否重复，先给arr[i]赋值，如果重复，则令i--，继续给当前元素赋值
arr[i] = (int)(Math.random()*30+1);
for (int j = 0; j < i; j++) {
if(arr[i] == arr[j]){
i--;
break;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
