Java：韩顺平 #课堂练习

崽崽今天要早睡

已于 2022-02-28 22:15:40 修改

阅读量555

点赞数

文章标签： java 开发语言

于 2022-02-13 09:08:09 首次发布

本文链接：https://blog.csdn.net/m0_46830519/article/details/122823558

版权

本文涵盖了Java编程的基础知识，包括字符串操作、文档注释、输出格式、运算符使用、循环控制、数组操作、排序算法和杨辉三角等。通过实例展示了如何使用System.out.println实现格式化输出，理解i++和++i的区别，运用三元运算符简化代码，以及实现冒泡排序和杨辉三角的数组生成。此外，还涉及到了键盘输入、数组动态扩展和缩小、求平均值和最大值等实际编程问题。

摘要由CSDN通过智能技术生成

持续更新中…

1.字符串练习：

public class ChangeCharTest{
	public static void main(String[] args){
		System.out.println("书名\t作者\t价格\t销量");
		System.out.println("三国\t罗贯中\t120\t1000");
		/*\\ 优化*/
		System.out.println("书名\t作者\t价格\t销量\n三国\t罗贯中\t120\t1000");

	}
}

在这里插入图片描述
总结：

在编程时注意单词的拼写正确
注意是英文下的符号
慢慢积累学会看报错信息

2.文档注释（常用）

/**
* @author [liu]
* @version [1.0]
 */
public class DocTest{
	public static void main(String[] args) {
		System.out.println("hello");
	}
}

D:\Java_code>javadoc -d D:\Java_code -author -version DocTest.java

3.输出如下格式，且只能使用一个System.out.println
在这里插入图片描述

public class ChangeCharTest{
	public static void main(String[] args){
		String name = "刘颜";
		int age = 23;
		float grade = 130.5;
		char gender = '女';
		String hobby = "网球、看书";
		System.out.println("姓名\t年龄\t成绩\t性别\t爱好\n"+name+"\t"
		+age+"\t"+grade+"\t"+gender+"\t"+hobby);
	}
}

总结：

明确变量的类型和值
输出中如果需要按照原样输出，就使用双引号；如果需要输出变量的值，就不要使用双引号；转义字符需要在双引号中

4.运算符

public class ChangeCharTest{
	public static void main(String[] args){
		System.out.println(10/4); -->2
		System.out.println(10.0/4); -->2.5
		double a = 10/4;
		System.out.println(a); -->2.0
	}
}

总结：

整数相除得到int类型的数据
浮点数和整数相除，按照高精度来定类型，即得到浮点数

5.i++和++i。注意对于自身赋值，会出现一个临时变量去保存数值
i++:①先将i赋值给temp，此时temp=1；②自加，此时i=2;③最后把temp赋值给i，此时i=1

public class test{
	public static void main(String[] args) {
		int i = 1;
		i = i++;
		System.out.println(i);
	}
}

++i①自加，此时i=2;②再将i赋值给temp，此时temp=2；③最后把temp赋值给i，此时i=2

public class test{
	public static void main(String[] args) {
		int i = 1;
		i =++i;
		System.out.println(i);
	}
}

6.三元运算符
口诀：一真大师
注意：
① 此处是++用法作为表达式使用，且得到的值需要赋值给result，因此不需要临时变量temple
② 表达式1、2的数据类型<=result的数据类型，如果不满足，可以进行强制转换类型

public class test{
	public static void main(String[] args) {
		int a = 1;
		int b = 2;
		int result = a < b ? a ++ : - - b ; 
		// 条件成立，将a 先赋值给result，然后a自加
		int result = a > b ? a ++ : - - b ; 
		// 条件不成立，先将b减1后赋值给result
	}
}

7.键盘输入

import java.util.Scanner; // 1.导入java.util包下的Scanner类
public class Input {
		public static void main(String []args) {
		Scanner myScanner = new Scanner(System.in);	
		//2.使用new创建一个Scanner对象，myScanner就是Scanner类的对象
		System.out.println("请输入名字：");//3.使用类下面的方法，接收用户的输入
		String name = myScanner.next();
    }
}

8.打印金字塔
总结：
外循环中的条件判断语句决定行数；
内循环的条件判断语句决定每行的个数

public class tt {
public static void main(String []args) {
	//① 需求：
	//打出一个空心金字塔
	//    *
	//   * *
	//  *   *
	// *     *
	//*********
	//② 分析：
	//化繁为简：
	//1.首先打印出一个矩形：
	//*****  每层有5个*
	//*****
	//*****
	//*****
	//*****
	//2.首先打印出一个三角形：
	//* 		1
	//** 		2
	//***		3
	//****		4
	//*****		5
	//3.首先打印出一个金字塔：
	//    * 		1  4=5-1
	//   *** 		3  3=5-2
	//  *****		5  2=5-3
	// *******		7  1=5-4
	//*********		9  0=5-5
	//4.首先打印出一个空心金字塔：
	//    * 		除了最后一层全部输出，其他层数只输出一头一尾的*
	//   * * 		
	//  *   *		
	// *     *		
	//*********	
	//先死后活：
	//行数定义一个变量
	int num = 10;	
	for(int j = 1; j <= num ; j++){
		for(int m = 1; m<=num-j ; m++){
			System.out.print(" ");
		}
		for(int i = 1; i <= 2*j-1 ; i++){
		if(i==1||i==2*j-1||j==num){
			System.out.print("*");
		}else{
			System.out.print(" ");
			}	
		}
		System.out.print("\n");
	}	
  }
}

9.乘法表

public class tt {
public static void main(String []args) {
	for(int i = 1 ; i <= 9 ; i++){
		for(int j = 1 ; j <= i ; j++){
			System.out.print(j+"*"+i+"="+i*j+"\t");
		}
		System.out.print("\n");
	}
  }
}

10.循环
输出1-100内不能被5整除的数，且每行5个
总结：要求每行5个，那就用count计数器

public class breakDemo {
public static void main(String []args) {
		int count = 0;
		for(int j = 1;j<=100;j++){
			if(j%5!=0){			
				System.out.print(j+"\t");
				count++;
				if(count%5==0){
					System.out.print("\n");
					continue;
				}
			}			
		}
	}
  }

11.输出a-z、z-a
总结:字符也可以放到循环里面比较大小
char的本质是一个整数，可以和整数进行加减，但是最终输出字母

public class breakDemo {
public static void main(String []args) {
		for(char num = 'a';num<='z';num++){
			System.out.print(num+" ");
		}
		System.out.print("\n");
		for(char num2 = 'z';num2>='a';num2--){
			System.out.print(num2+" ");
		}
	}
  }

12.注意数学公式中的陷阱
1-1/2+1/3-1/4…1/100
此处要将数学公式中的1表示成1.0

public class breakDemo {
public static void main(String []args) {
	double sum = 0;
		for(int i =1;i<=100;i++){
			if(i%2==0){
				double num1 = -(1.0/i);
				sum += num1;
			}else{
				double num2 = 1.0/i;
				sum += num2;
			}	 
		}
		System.out.print(sum);
	}
  }

13.逆序输出数组

public class breakDemo {
public static void main(String []args) {
	//第一种思路：将数组的前后数值进行交换
	//a={11,22,33,44,55,66}
	//a[0]~a[5]
	//a[1]~a[4]
	//a[2]~a[3]
	//i~length-i-1
	int[] a = {11,22,33,44,55,66};
	int[] c = {11,22,33,44,55,66};
	for(int i=0;i<a.length/2;i++){
		int temp = a[i];
		a[i] = a[a.length-1-i];
		a[a.length-1-i] = temp;
	}
	for(int i=0;i<a.length;i++){
		System.out.print(a[i]);
	}
	//第二种思路：将原数组逆序赋值给新的数组
	//a[0]~b[5]
	//a[1]~b[4]
	//a[2]~b[3]
	//a[3]~b[2]
	//a[4]~b[1]
	//a[5]~b[0]
	//一共需要赋值6次
	System.out.print("###################");
	int len = c.length;
	int [] b = new int [len];
	for(int i=0;i<len;i++){
		b[len-i-1] = c[i];
	}
	for(int i = 0; i<len; i++){
		System.out.print(b[i]);
	}
	}
  }

14.给数组动态增加一个用户输入的数

import java.util.Scanner;
public class breakDemo {
public static void main(String []args) {
	int [] a = {1,2,3};
	do{
		int [] b = new int[a.length+1];
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入数据：");
		int c = myScanner.nextInt();
		for(int i=0;i<a.length;i++){
			b[i] = a[i];
		}
		//将用户输入数据动态放入数组
		b[a.length] = c;
		//输出此时的新数组
		a = b;//将b的地址赋值给a
		//遍历输出a数组
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]);
		}
		//询问用户是否继续输入
		System.out.print("\n是否继续输入：y/n?\n");
		char d = myScanner.next().charAt(0);
		if(d=='n'){
			break;
		}
	}while(true);
	}
  }

15.缩小数组

import java.util.Scanner;
public class breakDemo {
public static void main(String []args) {
	int [] a = {1,2,3,4,5};
	do{
		int [] b = new int[a.length-1];
		Scanner myScanner = new Scanner(System.in);
		for(int i=0;i<a.length-1;i++){
			b[i] = a[i];
		}
		a = b;
		System.out.print("新的数组是：\n");
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+"\t");
		}
		//询问用户是否继续输入
		System.out.print("\n是否继续缩小：y/n?\n");
		char d = myScanner.next().charAt(0);
		if(d=='n'){
			break;
		}
		if(a.length==1){
			System.out.print("不能继续缩小了\n");
			break;
		}
	}while(true);
	}
  }

16.冒泡排序

public class breakDemo {
public static void main(String []args) {
	int [] a = {24,69,80,57,13,100,555,666};
	int temp = 0;
	for(int j =1;j<a.length;j++){
		for(int i=0;i<a.length-j;i++){
			if(a[i]>a[i+1]){
				temp = a[i+1];
				a[i+1] = a[i];
				a[i] = temp;
				if(i==a.length-2){
					break;
				}
			}
		}	
	}
	for(int i=0;i<a.length;i++){
			System.out.print(a[i]+"\t");
		}
	}
  }

老韩思路：


public class BubbleSort { 

	//编写一个main方法
	public static void main(String[] args) {

		//老韩 化繁为简，先死后活
		//
		//
		
		
		
		/*
			数组 [24,69,80,57,13]
			第1轮排序: 目标把最大数放在最后
			第1次比较[24,69,80,57,13]
			第2次比较[24,69,80,57,13]
			第3次比较[24,69,57,80,13]
			第4次比较[24,69,57,13,80]

		 */
		int[] arr = {24, 69, 80, 57, 13, -1, 30, 200, -110};
		int temp = 0; //用于辅助交换的变量

		//将多轮排序使用外层循环包括起来即可
		//先死后活 =》 4就是 arr.length - 1
		for( int i = 0; i < arr.length - 1; i++) {//外层循环是4次

			for( int j = 0; j < arr.length - 1 - i; j++) {//4次比较-3次-2次-1次
				//如果前面的数>后面的数，就交换
				if(arr[j] > arr[j + 1]) {
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;  
				}
			}
			System.out.println("\n==第"+(i+1)+"轮==");
			for(int j = 0; j < arr.length; j++) {
				System.out.print(arr[j] + "\t");
			}

		}

		// for( int j = 0; j < 4; j++) {//4次比较
		// 	//如果前面的数>后面的数，就交换
		// 	if(arr[j] > arr[j + 1]) {
		// 		temp = arr[j];
		// 		arr[j] = arr[j+1];
		// 		arr[j+1] = temp;  
		// 	}
		// }

		// System.out.println("==第1轮==");
		// for(int j = 0; j < arr.length; j++) {
		// 	System.out.print(arr[j] + "\t");
		// }
		// /*
		// 第2轮排序: 目标把第二大数放在倒数第二位置
		// 第1次比较[24,69,57,13,80]
		// 第2次比较[24,57,69,13,80]
		// 第3次比较[24,57,13,69,80]
		//  */
		
		// for( int j = 0; j < 3; j++) {//3次比较
		// 	//如果前面的数>后面的数，就交换
		// 	if(arr[j] > arr[j + 1]) {
		// 		temp = arr[j];
		// 		arr[j] = arr[j+1];
		// 		arr[j+1] = temp;  
		// 	}
		// }

		// System.out.println("\n==第2轮==");
		// for(int j = 0; j < arr.length; j++) {
		// 	System.out.print(arr[j] + "\t");
		// }

		
		// 第3轮排序: 目标把第3大数放在倒数第3位置
		// 第1次比较[24,57,13,69,80]
		// 第2次比较[24,13,57,69,80]
		 
		
		// for( int j = 0; j < 2; j++) {//2次比较
		// 	//如果前面的数>后面的数，就交换
		// 	if(arr[j] > arr[j + 1]) {
		// 		temp = arr[j];
		// 		arr[j] = arr[j+1];
		// 		arr[j+1] = temp;  
		// 	}
		// }

		// System.out.println("\n==第3轮==");
		// for(int j = 0; j < arr.length; j++) {
		// 	System.out.print(arr[j] + "\t");
		// }

		// /*
		// 第4轮排序: 目标把第4大数放在倒数第4位置
		// 第1次比较[13,24,57,69,80]
		//  */
		
		// for( int j = 0; j < 1; j++) {//1次比较
		// 	//如果前面的数>后面的数，就交换
		// 	if(arr[j] > arr[j + 1]) {
		// 		temp = arr[j];
		// 		arr[j] = arr[j+1];
		// 		arr[j+1] = temp;  
		// 	}
		// }

		// System.out.println("\n==第4轮==");
		// for(int j = 0; j < arr.length; j++) {
		// 	System.out.print(arr[j] + "\t");
		// }

	}
}

17.杨辉三角


public class YangHui { 

	//编写一个main方法
	public static void main(String[] args) {
		/*
		使用二维数组打印一个 10 行杨辉三角
		1
		1 1
		1 2 1
		1 3 3  1
		1 4 6  4  1
		1 5 10 10 5 1

		规律
		 1.第一行有 1 个元素, 第 n 行有 n 个元素
		 2. 每一行的第一个元素和最后一个元素都是 1
		 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值. arr[i][j] 
		  arr[i][j]  =  arr[i-1][j] + arr[i-1][j-1]; //必须找到这个规律

		 */
		int[][] yangHui = new int[12][];
		for(int i = 0; i < yangHui.length; i++) {//遍历yangHui的每个元素

			//给每个一维数组(行) 开空间
			yangHui[i] = new int[i+1];
			//给每个一维数组(行) 赋值
			for(int j = 0; j < yangHui[i].length; j++){
				//每一行的第一个元素和最后一个元素都是1
				if(j == 0 || j == yangHui[i].length - 1) {
					yangHui[i][j] = 1;
				} else {//中间的元素
					yangHui[i][j]  =  yangHui[i-1][j] + yangHui[i-1][j-1];
				}
			}
		}
		//输出杨辉三角
		for(int i = 0; i < yangHui.length; i++) {
			for(int j = 0; j < yangHui[i].length; j++) {//遍历输出该行
				System.out.print(yangHui[i][j] + "\t");
			}
			System.out.println();//换行.
		}
	}
}

18.输入一个元素到升序数组后仍然满足升序


public class Homework04 { 
	//编写一个main方法
	public static void main(String[] args) {
		/*
		已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序, 比如:  
		[10， 12， 45， 90],  添加23 后, 数组为 [10， 12，23， 45， 90]
		思路 本质数组扩容 + 定位
		1. 我们先确定 添加数应该插入到哪个索引
		2. 然后扩容
		 */
		//先定义原数组
		int[] arr = {10, 12, 45, 90};
		int insertNum = 111;
		int index = -1; //index就是要插入的位置
		//遍历 arr数组， 如果发现 insertNum<=arr[i], 说明 i 就是要插入的位置
		//使用 index 保留 index = i;
		//如果遍历完后，没有发现 insertNum<=arr[i]， 说明 index = arr.length
		//即：添加到arr的最后
		for(int i = 0; i < arr.length; i++) {
			if(insertNum <= arr[i]) {
				index = i;
				break; //找到位置后，就退出
			}
		}
		//判断index 的值
		if(index == -1) { //说明没有还没有找到位置
			index = arr.length;
		}
		//扩容
		//先创建一个新的数组，大小 arr.length + 1
		int[] arrNew = new int[arr.length + 1];
		//下面老师准备将arr的元素拷贝到 arrNew ,并且要跳过 index位置
		/*
		分析:
		int[] arr = {10, 12, 45, 90};
		arrNew = {              }
		*/
		//i 控制arrNew的下标  , j用来控制arr数组的下标
		for(int i = 0, j = 0; i < arrNew.length; i++) {
			if( i != index ) { //说明可以把 arr的元素拷贝到 arrNew
				arrNew[i] = arr[j];
				j++;
			} else { //i这个位置就是要插入的数
				arrNew[i] = insertNum;
			}
		}
		//让arr 指向 arrNew , 原来的数组，就成为垃圾，被销毁
		arr = arrNew;
		System.out.println("======插入后，arr数组的元素情况======");
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
	}
}

19.数组扩容

import java.util.Scanner;
public class ArrayAdd02 { 
	//编写一个main方法
	public static void main(String[] args) {
		/*
		要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java
		1.原始数组使用静态分配 int[] arr = {1,2,3}
		2.增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
		3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
		思路分析
		1. 定义初始数组 int[] arr = {1,2,3}//下标0-2
		2. 定义一个新的数组 int[] arrNew = new int[arr.length+1];
		3. 遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
		4. 将 4 赋给 arrNew[arrNew.length - 1] = 4;把4赋给arrNew最后一个元素
		5. 让 arr 指向 arrNew ;  arr = arrNew; 那么 原来arr数组就被销毁
		6. 创建一个 Scanner可以接受用户输入
		7. 因为用户什么时候退出，不确定，老师使用 do-while + break来控制
		 */
		Scanner myScanner = new Scanner(System.in);
		//初始化数组
		int[] arr = {1,2,3};
		do {
			int[] arrNew = new int[arr.length + 1];
			//遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
			for(int i = 0; i < arr.length; i++) {
				arrNew[i] = arr[i];
			}
			System.out.println("请输入你要添加的元素");
			int addNum = myScanner.nextInt();
			//把addNum赋给arrNew最后一个元素
			arrNew[arrNew.length - 1] = addNum;
			//让 arr 指向 arrNew, 
			arr = arrNew;
			//输出arr 看看效果
			System.out.println("====arr扩容后元素情况====");
			for(int i = 0; i < arr.length; i++) {
				System.out.print(arr[i] + "\t");
			}
			//问用户是否继续
			System.out.println("是否继续添加 y/n");
			char key = myScanner.next().charAt(0);
			if( key == 'n') { //如果输入n ,就结束
				break;
			}			
		}while(true);
		System.out.println("你退出了添加...");
	}
}

20.求10个1-100之间的随机数的均值，最大值，及判断是否生成8


public class Homework05 { 

	//编写一个main方法
	public static void main(String[] args) {
		
		/*
		随机生成10个整数(1_100的范围)保存到数组，
		并倒序打印以及求平均值、求最大值和最大值的下标、
		并查找里面是否有 8  Homework05.java
		 */
		int[] arr = new int[10]; 
		//(int)(Math.random() * 100) + 1 生产 随机数 1-100
		for(int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random() * 100) + 1;
		}
		System.out.println("====arr的元素情况=====");
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println("\n====arr的元素情况(倒序)=====");
		for(int i = arr.length -1; i >= 0; i--) {
			System.out.print(arr[i] + "\t");
		}
		//平均值、求最大值和最大值的下标
		//我们这里将需要一起完成
		//
		double sum = arr[0];
		int max = arr[0];
		int maxIndex = 0;
		for(int i = 1; i < arr.length; i++ ) {
			sum += arr[i]; //累积和
			if( max < arr[i]) {//说明max不是最大值，就变化
				max = arr[i];
				maxIndex = i;
			}
		}
		System.out.println("\nmax=" + max + " maxIndex=" + maxIndex);
		System.out.println("\n平均值=" + (sum / arr.length));
		//查找数组中是否有8->使用顺序查找
		int findNum = 8;
		int index = -1; //如果找到，就把下标记录到 index
		for(int i = 0; i < arr.length; i++) {
			if(findNum == arr[i]) {
				System.out.println("找到数" + findNum + " 下标=" + i);
				index = i;
				break;
			}
		}
		if(index == -1) {
			System.out.println("没有找到数" + findNum );
		}
	}
}

21.创建类和对象

public class breakDemo {
public static void main(String []args) {
	//实例化一个猫对象
	//cat1是一个对象的名字
	Cat cat1 = new Cat();
	cat1.name = "小花";
	cat1.age = 3;
	cat1.color = "红色";
	//访问对象的属性
	System.out.print(cat1.name+"\t"+cat1.age);
	}
  }
  //创建一个猫类
class Cat{
	String name;
	int age;
	String color;
}

22.方法


public class Method01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//方法使用
		//1. 方法写好后，如果不去调用(使用)，不会输出
		//2. 先创建对象 ,然后调用方法即可
		Person p1 = new Person();
		p1.speak(); //调用方法
		p1.cal01(); //调用cal01方法
		p1.cal02(5); //调用cal02方法，同时给n = 5
		p1.cal02(10); //调用cal02方法，同时给n = 10
		
		//调用getSum方法，同时num1=10, num2=20
		//把 方法 getSum 返回的值，赋给 变量 returnRes
		int returnRes = p1.getSum(10, 20); 
		System.out.println("getSum方法返回的值=" + returnRes);
	}
}

class Person {
	
	String name;
	int age;
	//方法(成员方法)
	//添加speak 成员方法,输出 “我是一个好人”
	//老韩解读
	//1. public 表示方法是公开
	//2. void ： 表示方法没有返回值
	//3. speak() : speak是方法名， () 形参列表
	//4. {} 方法体，可以写我们要执行的代码
	//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
	
	public void speak() {
		System.out.println("我是一个好人");
	}

	//添加cal01 成员方法,可以计算从 1+..+1000的结果
	public void cal01() {
		//循环完成
		int res = 0;
		for(int i = 1; i <= 1000; i++) {
			res += i;
		}
		System.out.println("cal01方法 计算结果=" + res);
	}
	//添加cal02 成员方法,该方法可以接收一个数n，计算从 1+..+n 的结果
	//老韩解读
	//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
	public void cal02(int n) {
		//循环完成
		int res = 0;
		for(int i = 1; i <= n; i++) {
			res += i;
		}
		System.out.println("cal02方法 计算结果=" + res);
	}

	//添加getSum成员方法,可以计算两个数的和
	//老韩解读
	//1. public 表示方法是公开的
	//2. int :表示方法执行后，返回一个 int 值
	//3. getSum 方法名
	//4. (int num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数
	//5. return res; 表示把 res 的值， 返回
	public int getSum(int num1, int num2) {
		int res = num1 + num2;
		return res;
	}
}

23.方法返回多个数

public class breakDemo {
public static void main(String []args) {
	Arr myArr = new Arr();
	//用一个数组去接收
	int Getme[] = myArr.method(1,2);
	for(int i=0;i<Getme.length;i++){
		System.out.println(Getme[i]);
	}	
	}
}
class Arr{
	public int[] method(int n1,int n2){
		int [] arr = new int [2];
		arr[0] = n1+n2;
		arr[1] = n1-n2;
		return arr;//返回一个数组
	}
}