Java基础笔记4

最新推荐文章于 2024-07-10 21:37:49 发布

02。Tender

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量38

点赞数

分类专栏：笔记文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/qq_56576430/article/details/128442226

版权

笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java基础

1. 循环相关

1.1do...while

do...while语法规则：

语句0 ;

do{

语句1;//循环体

语句2;//

}while （循环条件）;

语句3 ;

对比while循环

while循环先判断，再执行;

做。。。而先执行一次，再判断。

虽然循环比做...同时循环用得多。

代码

package day5;
import java.util.Scanner;
// do { 语句 } while(条件); , 特点是：循环体至少执行一次。
public class DoWhileDemo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
/*
int num ;
do{
System.out.println("请输入一个数据");
num = scanner.nextInt();
}while (num != 30 );
*/
// 练习： 输入密码（ 123456 ）解锁手机， 只能输入 5 次，超过 5 次了就提示用户过半个小
时在尝试。
int count = 1 ; // 记录次数
int pwd ;
do{
if(count == 6 ){
System.out.println("你的输入次数用完了，请半个小时之后，在尝试。");
//break; 结束循环
return;  // 结束整个程序的运行
}
System.out.println("请输入密码：");
pwd = scanner.nextInt();
count ++ ;// 改变输入的次数
}while (pwd != 123456 );
System.out.println("手机解锁成功了。");
}

1.2死循环

循环没有指明结束条件的情况会造成死循环

1.3中断并继续

break可用于循环语句或switch语句。

break用于循环，可使程序终止循环从而执行循环后面的语句。常常与条件语句一起使用。

continue 用于循环语句中，表示跳过循环体剩余语句，继续执行下一次循环。

continue 只能在循环语句中使用。

代码

}

package day5;
import java.util.Scanner;
// 随机出 10 道题， 记录用户的考试分数，每题 10 分.
public class TestDemo {
public static void main(String[] args){
int score = 0 ; // 用于记录分数
Scanner sc = new Scanner(System.in);
for(int i= 1 ;i <= 10 ;i ++){
int a = (int)(Math.random() * 10 );// 强制转换
int b = (int)(Math.random() * 10 );
System.out.println("题目：" + a + " + " + b + "=");
System.out.println("请输入你的答案：");
int answer = sc.nextInt() ;
if(answer == - 1 ){ // 表示用户跳过这题
continue; // java中的关键字， 用于跳过本次循环， 继续下一次循环。
}else if(answer == - 2 ){
break; // 结束for循环
}else {
if(answer == a+b){
score += 10 ;  // 记录分数
}
}
}
// for循环结束，表示考试结束了，显示最终得分
System.out.println("最后得分：" + score);

1.3循环的嵌套

循环的内部，再有其它循环，就是循环的嵌套。

外层走一次，内层走所有次

建议循环层数越少越好

代码

2. 数组

2.1什么是数组

数组：相同数据类型的元素组成的集合

元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最

后一个元素外，每一个元素都有唯一的后继元素（"一个跟一个"）,可以通过元素所在位置的顺序号

（下标）做标识来访问每一个元素（下标从 0 开始，最大到元素的个数-1）

2.2数组的使用

}

循环的嵌套：循环的内部，还包含一个循环。

*** 外层循环执行一次，内层循环执行所有次。（内部循环执行结束了，再次执行到外层

循环的下一次。）

public class JiuJiuDemo {
public static void main(String[] args) {
for(int i = 1 ; i <= 9 ; i ++){  // 外层循环
for(int j = 1 ;  j <= i; j++){ // j<=i ，可以设置内层循环的次数。
System.out.print( i + "+" + j + "=" + (i+j) + "\t"); // \t转
移字符， tab键的宽度
}
System.out.println(); // 输出一个回车换行
}
}
}

声明数组的语法：

数据类型[] 数组名 = new 数据类型[大小]；

数组声明后的默认值

------数组new之后，每个元素都有默认值。int,long默认值为 0 ，double默认值为0.0，boolean

默认值为false,char默认值为空字符。

代码

package day5;
// array - 数组
// 当我们有一组数据需要保存在一个变量中的时候，一般可以声明一个对应长度和对应数据类型的数
组， 然后把这组数据存储在数组中。
public class ArrayDemo {
public static void main(String[] args) {
// 1. 定义一个数组
//int a = 1,b=10,c=20,d=30,e=50; // 定义了五个变量，存储了五个数据。
int[] arr ; // arr是数组类型
//arr = new int[]; // 编译错误： java规定创建数组对象的时候，必须指定数组的长
度。
arr = new int[ 6 ]; // 内存空间会分配存储长度为 6 个整形数据空间。
// 2. 数组的初始化
int[] arr1 = new int[ 5 ]; // arr1的长度是5. 这里的每个元素都是int类型的默认
值：0.
char[] arr2 = {'A','B','A', 10 } ; // arr2的长度是 4 ，每个位置的元素已经指
定了。
double[] arr3 = new double[]{1.5,2.5,3.5,4.5}; //arr3的长度 4 ， 每个位
置都有具体的数据。
// 3. 通过数组的下标（从 0 开始，到元素个数-1结束）访问到数据中的元素。
/*
System.out.println(arr1[0]); // arr1[下标]
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println(arr1[3]);
System.out.println(arr1[4]); // 数组长度是 5 ， 下标值： 0 ， 1 ， 2 ， 3 ， 4 ， 其
它数据，则发生异常。
*/
for(int i= 0 ;i < 5 ; i++){
System.out.println(arr1[i]); // arr1[i] , i 从 0 逐渐变化到4. 正好就
是数组的每一个元素。
}

数组的交换位置

}

package day5;
public class ArrayDemo2 {
public static void main(String[] args) {
// 1. 创建整形数组
int[] arr = new int[]{ 10 , 15 , 8 , 40 , 25 , 5 };
// 2. 把数组中最大的数据值移动到最末位。
for(int i= 0 ; i <= arr.length - 2 ; i ++){
if(arr[i] < arr[i+ 1 ]){ // 当前元素 小于 下一个元素， 不交换位置， 反之
交换位置
continue; // 跳出本次循环
}else{
int temp = arr[i];
arr[i] = arr[i+ 1 ];
arr[i+ 1 ] = temp;
}
}
// 3. 遍历输出数组的元素
for(int i = 0 ; i < arr.length ; i ++ ){
System.out.println(arr[i]);
}
// 4. 练习：把最小值移动末尾
for(int i = 0 ; i < arr.length - 1 ; i++){
if(arr[i] < arr[i+ 1 ]){// 当前元素，小于下一个元素，说明需要交换位置。
int temp = arr[i];
arr[i] = arr[i+ 1 ];
arr[i+ 1 ] = temp ;
}
}
// 5. 遍历输出数组的元素
System.out.println("最末尾是最小的：");
for(int i = 0 ; i < arr.length ; i ++ ){ // 假设： i <= arr.length
// i = 0,1,2,3,4,5,6 , 下
标只能是 0 ， 1 ， 2 ， 3 ， 4 ， 5 ，
// i=6 数据数据arr[6] , 找
不到 ， 程序处理不了， 就抛异常
System.out.print(arr[i] + "\t");
}
/*
Exception : 异常
ArrayIndexOutOfBoundsException : array 数组 ， index 索引 ， out of
bounds 超出边界
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:
6
at day5.ArrayDemo2.main(ArrayDemo2.java:33) // 类中的第 33 行。
*/
}
}

2.3数组的排序

冒泡排序:所谓的冒泡算法就是从左往右依次比较两个数大小，若前一个数大于后一个数，则两个数

交换位置

升序

降序

package day5;
// bubble: 泡
// 冒泡排序： 双重for循环， 外层for循环走一次，内层循环周n次， 就能把数组中的一个元素的位
置排好 。
public class BubbleDemo {
public static void main(String[] args) {
int[] arr = new int[]{ 10 , 15 , 8 , 40 , 25 , 5 };
// 1. 升序排序
for(int i= 0 ; i < arr.length - 1 ; i++ ){
for(int k = 0 ; k < arr.length - 1 ; k++){ // k = 0 ， 1 ， 2 ， 3 ， 4
， k+1 = 1,2,3,4,
if(arr[k] < arr[k+ 1 ]){
continue;
}else{ // 下一个小，就交换位置
int temp = arr[k];
arr[k] = arr[k+ 1 ];
arr[k+ 1 ] = temp ;
}
}
}
// 2. 输出升序数组
for(int i= 0 ; i < arr.length ; i++){
System.out.print(arr[i] + "\t");
}
}
}
package day5;
// bubble: 泡
// 冒泡排序： 双重for循环， 外层for循环走一次，内层循环周n次， 就能把数组中的一个元素的位
置排好 。
public class BubbleDemo1 {
public static void main(String[] args) {
int[] arr = new int[]{ 10 , 15 , 8 , 40 , 25 , 5 };
// 1. 降序排序
for(int i= 0 ; i < arr.length - 1 ; i++ ){
for(int k = 0 ; k < arr.length - 1 ; k++){ // k = 0 ， 1 ， 2 ，
3 ， 4 ， k+1 = 1,2,3,4,
if(arr[k] < arr[k+ 1 ]){
int temp = arr[k];
arr[k] = arr[k+ 1 ];
arr[k+ 1 ] = temp ;
}
}
}

数组排序函数排序

Arrays.sort（）——jdk提供的排序方法。

数组复制

JDK提供对数组进行复制的方法，即将一个数组（源数组）中的各个元素值复制到另一个数组（目

标数组）中：

数组扩容

数组的长度在创建后不可以改变的。所谓"扩展"是指创建一个更大新数组，并将原有数组的内容复

制到其中。

Jdk提供了一个方法，Arrays.copyOf 可以实现数组的“扩容”