从今天开始，积累写过的java代码

 1，打印三位数

/*
练习：随意给出一个三位数的整数，打印显是它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：

例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1

*/
class  AriExer
{
	public static void main(String[] args) 
	{
		int num = 345;
		int bai = num / 100;
		int shi = num % 100 / 10;//int shi = num / 10 % 10;
		int ge = num % 10;
		System.out.println("百位为：" + bai);
		System.out.println("十位为：" + shi);
		System.out.println("个位为：" + ge);
	}
}

小练习：交换两个变量值

// 练习：交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 =" + num1 + ",num2 = " + num2);

		/*
		方式一：定义临时变量。具有通用性，推荐。
		int temp = num1;
		num1 = num2;
		num2 = temp;
		System.out.println("num1 =" + num1 + ",num2 = " + num2);
		*/
		/*方式二:不用定义临时变量，但是相加操作可能超出存储范围，有局限性，只能用于数值型。
		num1 = num1 + num2;
		num2 = num1 - num2;
		num1 = num1 - num2;
		System.out.println("num1 =" + num1 + ",num2 = " + num2);
		*/
		//方式三：使用位运算符 关系式：m = k ^ n = (m ^ n) ^ n，有局限性，只能用于数值型。
		num1 = num1 ^ num2;
		num2 = num1 ^ num2;
		num1 = num1 ^ num2;
		System.out.println("num1 =" + num1 + ",num2 = " + num2);

小练习：获取三个数的最大值

//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;

		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		System.out.println("三个数中的最大值为：" + max2);
		//不建议
		int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
		System.out.println("三个数中的最大值为：" + max3);

编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。否则，打印两数的乘积

	double b1 = 1.2,b2 = 512.1;
	if((b1>=10.0 )&&(b2<=20.0)){
		System.out.println("两个数之和："+ (b1+b2));
	}else{
		System.out.print("两个数之积："+(b1*b2));
			} 

求一个0~255内一个数的十六进制转化，例如六十的十六进制表示3C

//方式1：自动
String str1 = Integer.toBinaryString(60);
String str2 = Integer.toHexString(60);

//方式2：手动
	int i1 = 60;
	int i2 = i1&15;
	String j = (i2 > 9)?(char)(i2-10 + 'a') + "" : i2 + "";
	int temp = i1 >>> 4;
	i2 = temp & 15;
	String k = (i2 > 9)?(char)(i2-10 + 'a') + "" : i2 + "";
	System.out.println(k + "" + j);

if练习1

/*
岳小鹏参加Java考试,他和父亲岳不群达成承诺:
如果:
成绩为100分时,奖励一辆BMW;
成绩为(80，99]时,奖励一台iphone xs max;
当成绩为[60,80]时,奖励一个iPad;
其它时,什么奖励也没有。
请从键盘输入岳小鹏的期末成绩,并加以判断


*/
import java.util.Scanner;
class IfTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);//获取控制台输入

		System.out.println("请输入岳小鹏的期末成绩：(0-100)");
		int score = scan.nextInt();

		if(score == 100){
			System.out.println("奖励一辆马自达");
		}else if(score > 80 && score <=99){
			System.out.println("奖励一台小米 xs max");
		}else if(score >= 60 && score <=80){
			System.out.println("奖励一个Pad");
		}else{
			System.out.println("奖励一个大逼斗！");
		}
	}
}

if练习2

/*
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序（使用 if-else ），并且从小到大输出。


说明：
1.if-else结构是可以相互嵌套的
2.如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。一般不建议。
*/
import java.util.Scanner;
class IfTest2 {
	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);

		System.out.println("请输入第一个整数：");
		int num1 = scanner.nextInt();
		System.out.println("请输入第二个整数：");
		int num2 = scanner.nextInt();
		System.out.println("请输入第三个整数：");
		int num3 = scanner.nextInt();

		if(num1 >= num2){
			if(num3 >= num1){
				System.out.println(num2 + "," + num1 + "," + num3);
			}else if(num3 <= num2){
				System.out.println(num3 + "," + num2 + "," + num1);
			}else{
				System.out.println(num2 + "," + num3 + "," + num1);
			}
	}else{//num1 < num2
		if(num3 >= num2){
				System.out.println(num1 + "," + num2 + "," + num3);
			}else if(num3 <= num1){
				System.out.println(num3 + "," + num1 + "," + num2);
			}else{
				System.out.println(num1 + "," + num3 + "," + num2);
			}
	}
	}
}

调用Scanner

/*
如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：
1.导包：import java.util.Scanner;
2,Scanner的实例化
3.调用Scanner类的相关方法(next() / nextXxx()),来获取指定类型的变量

注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的数据类型不匹配时，会报异常InputMismatchException，导致程序终止。
*/

import java.util.Scanner;
class ScannerTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		//调用Scanner类的相关方法:
		System.out.println("请输入你的姓名：");
		String name = scan.next();
		System.out.println(name);

		System.out.println("请输入你的年龄：");
		int age = scan.nextInt();
		System.out.println(age);

		System.out.println("请输入你的体重：");
		double weight = scan.nextDouble();
		System.out.println(weight);

		System.out.println("你喜欢miku吗？(true/false)");
		boolean islove = scan.nextBoolean();
		System.out.println(islove);

		//对于char型的获取，Scanner没有提供相关方法。只能获取一个字符串
		System.out.println("请输入你的性别：(男/女)");
		String gender = scan.next();//"男"
		char genderChar = gender.charAt(0);//获取索引为0位置上的字符
		System.out.println(genderChar);

		//int num = scan.nextInt();
		//System.out.println(num);
	}
}

相亲啦！

/*
大家都知道,男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件:高:180cm以上;富:财富1千万以上;帅:是。
≥如果这三个条件同时满足，则:“我一定要嫁给他!”
如果三个条件有为真的情况，则:“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则:“不嫁!”

*/
import java.util.Scanner;

class IfExer1 {
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in);


		System.out.println("请输入你的身高：(cm)");
		int height = scan.nextInt();
		System.out.println("请输入你的财富：(千万)");
		double wealth = scan.nextDouble();
		/*
		方式一：
		System.out.println("你是否是倾城大帅比：(true/false)");
		boolean isHandsome = scan.nextBoolean();

		if(height >= 180 && wealth >= 1 && isHandsome){
			System.out.println("我一定要嫁给他！！！");
		}else if(height >= 180 || wealth >= 1 || isHandsome){
			System.out.println("嫁吧，有总比没有好。。。");
		}else{
			System.out.println("穷屌丝还敢相亲？gunb！");
		}
		*/
		
		//方式二：
		System.out.println("你是否是倾城大帅比：(是/否)");
		String isHandsome = scan.next();

		if(height >= 180 && wealth >= 1 && isHandsome.equals("是")){
			System.out.println("我一定要嫁给他！！！");
		}else if(height >= 180 || wealth >= 1 || isHandsome.equals("是")){
			System.out.println("嫁吧，有总比没有好。。。");
		}else{
			System.out.println("穷屌丝还敢相亲？gunb！");
		}
	}
}

买彩票咯

/*
假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，
提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金3 000美元。
3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
提示：使用(int)(Math.random() * 90  + 10)产生随机数。
Math.random() : [0,1)  * 90 [0,90) + 10 [10,100)[10,99]

*/
import java.util.Scanner;//引入Scanner

class  LuckyTicket{
	public static void main(String[] args) {
		//重点1.随机生成一个两位数，在[0,99)内
		int number = (int)(Math.random() * 90 + 10);//得到[10,100)
		//定义随机两位数的十位个位
		int num1 = number / 10;
		int num2 = number % 10;
		//重点2.用户输入一个两位数
		Scanner input = new Scanner(System.in);//获取控制台输入
		System.out.println("请输入你想购买的号码： （两位）");
		int guess = input.nextInt();//引用nextInt赋值guess为控制台输入的值
		//定义guess的十位个位
		int gue1 = guess / 10,gue2 = guess % 10;
		//if-else结构判断条件是否符合
		if (number == guess){
			System.out.println("恭喜！获得奖金10 000刀乐！");
		}else if (num1 == gue1 && num2 ==  gue2 ){
			System.out.println("真不戳~获得奖金3 000刀乐！");
		}else if(num1 == gue1 || num2 ==  gue2){
			System.out.println("诶嘿，获得奖金1 000刀乐。");
		}else if(num1 == gue2 || num2 ==  gue1){
			System.out.println("还行...获得奖金500刀乐。");
		}else
			System.out.println("这都没中？彩票作废...");
			System.out.println("本期彩票号码是：" + number);
			
	}
}

用switch-else结构改变输入字母大小写题

/*
使用switch 把小写类型的char型转为大写。只转换a，b，c，d，e，其他的输出“other”。
提示：String word =scan.next(); char c = word.charAt(0);  switch(c){}
*/
import java.util.Scanner;

class ChangeLetter{
	public static void main(String[] args) {
	Scanner scan = new Scanner(System.in);	
	String word = scan.next();
	char c = word.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;
		}
		case 'd': {
			System.out.println("D");
			break;
		}
		case 'e': {
			System.out.println("E");
			break;
		}
		default:{
			System.out.println("other");
		}
	}
		
	}
}

输入年月日判断日子

/*
从键盘分别输入年，月，日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：可以被4整除，但不可以被100整除 || 可以被400整除

说明:
1凡是可以使用switch-case的结构,都可以转换为if-else。反之,不成立。
2.我们写分支结构时,当发现既可以使用switch-case,〔(同时,switch中表达式的取值情况不太多),
又可以使用，我们优先选择使用switch-case。原因:switch-case执行效率稍高。

*/


import java.util.Scanner;
class SwitchCaseExer {
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in);
		System.out.println("请输入年份：");
		int year = scan.nextInt();
		System.out.println("请输入月份：");
		int month = scan.nextInt();
		System.out.println("请输入日子：");
		int day = scan.nextInt();

		int sumDays = 0;

		switch (month){
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			//sumDays += 28;
		    //判断year是否为闰年
			if((year % 4 == 0 && year % 100 !=0) || year % 400 == 0 ){
			sumDays += 29;
			}else sumDays += 28;
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}
		System.out.println( year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
	}

水仙花数

/*
输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如：153 = 1*1*1 + 3*3*3 + 5*5*5

*/
class ForTest2{
	public static void main(String[] args){
		for(int i = 100;i <= 999;i++){
			int a = i / 100;	//获取百位
			int b = i % 100 /10;	//获取十位
			int c = i % 10;	//获取个位
			if(a*a*a + b*b*b + c*c*c == i){
				System.out.println("此数值为满足条件的水仙花数:" + i);
			}
		}
	}
}

彩票2.0！！！

/*
假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，
提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金3 000美元。
3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
提示：使用(int)(Math.random() * 90  + 10)产生随机数。
Math.random() : [0,1)  * 90 [0,90) + 10 [10,100)[10,99]

新功能：当你输入非两位数的时候会温柔的提示你重新输入
*/
import java.util.Scanner;//引入Scanner

class  LuckyTicket2{
	public static void main(String[] args) {
		//重点1.随机生成一个两位数，在[0,99)内
		int number = (int)(Math.random() * 90 + 10);//得到[10,100)
	
		int num1 = number / 10;
		int num2 = number % 10;
		
		Scanner input = new Scanner(System.in);
		System.out.println("欢迎~光~临！本彩票店每张彩票300刀乐，请问您是否购买？  (是/否)");
		String goumai = input.next();
		if (goumai.equals("是")){	
			System.out.print("感谢亲的购买~" + "\n");
		}else if(goumai.equals("否")){
			System.out.println("嘁，穷逼886！");
			return;
		}else{ 
			System.out.println("不买别捣乱，走走走！");
			return;
		}

		System.out.println("请输入你想购买的号码： （两位）");

		int guess = input.nextInt();

		if (guess >99 || guess < 10);
		do {
			System.out.print("小学没学好？给我输入两位数！" + "\n" + "\n");
			System.out.println("请输入你想购买的号码： （两位！！！！！！）" );
			guess = input.nextInt();
		}while (guess >99 || guess < 10);
		
		int gue1 = guess / 10,gue2 = guess % 10;

		if (number == guess){
			System.out.println("恭喜！获得奖金10 000刀乐！");
		}else if (num1 == gue1 && num2 ==  gue2 ){
			System.out.println("真不戳~获得奖金3 000刀乐！");
		}else if(num1 == gue1 || num2 ==  gue2){
			System.out.println("诶嘿，获得奖金1 000刀乐。");
		}else if(num1 == gue2 || num2 ==  gue1){
			System.out.println("还行...获得奖金500刀乐。");
		}else
			{System.out.println("这都没中？彩票作废...");
			
			}System.out.println("本期彩票号码是：" + number);

			
	}
}

 杨辉三角

/*使用二维数组打印一个 10 行杨辉三角。
 * 【提示】
 * 1. 第一行有 1 个元素, 第 n 行有 n 个元素
 * 2. 每一行的第一个元素和最后一个元素都是 1
 * 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。
 * 即：yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
 */

public class ArrayExer2 {
public static void main(String[] args) {
	//1.声明并初始化二维数组
	int yanghui[][]=new int[10][];
	//2.给数组的元素赋值，遍历二维数组
	for (int i = 0; i < yanghui.length; i++) {
		yanghui[i] = new int[i+1];
	//2.1 给首末元素赋值
		yanghui[i][0] = yanghui[i][i] = 1;
	//2.2 给每行的非首末元素赋值
	for (int j = 1; j < yanghui[i].length -1; j++) {
			yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
		}
	}
	//	3.遍历数组
	for (int i = 0; i < yanghui.length; i++) {
		for (int j = 0; j < yanghui[i].length; j++) {
			System.out.print(yanghui[i][j] + " ");
		}
			System.out.println();
	}
}
}

 数组相关

/*
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
    然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
   要求：所有随机数都是两位数。
提示；
[0,1) * 90 [0,90) + 10  [10,100) [10,99]
(int)(Math.random() * 90 + 10)
 */
public class Arraytest1 {
public static void main(String[] args) {
	int[] arr = new int[10];
	//获取随机数
	for (int i = 0; i < arr.length; i++) {
		arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
	}
	//遍历
	for (int i = 0; i < arr.length; i++) {
		System.out.print(arr[i] + "\t");
	}
	System.out.println();
	//求数组元素的最大值
	int maxValue = arr[0];//不能定义为0，以免出现负数情况无法准确求出最大值。
	for (int i = 0; i < arr.length; i++) {
		if (maxValue < arr[i]) {
			maxValue = arr[i];
		}
	}
	System.out.println("最大值为：" + maxValue);
	//求数组元素的最小值
	int minValue = arr[0];
	for (int i = 0; i < arr.length; i++) {
		if (minValue >arr[i]) {
			minValue = arr[i];
		}
	}
	System.out.println("最小值为：" + minValue);
	//求数组元素的总和
	int sum = 0;
	for (int i = 0; i < arr.length; i++) {
		sum += arr[i];
	}
	System.out.println("总和为：" + sum );
	//求数组元素的平均数
	double avgValue = sum / arr.length;
	System.out.println("平均数为：" + avgValue);


}
}

斐波那契数列

package CircleTest;
//例4:计算斐波那契数列的第n个值，并将整个数列打印出来
//输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
//1  1  2  3  5  8  13  21  34  55
//规律：一个数等于前两个数之和
//要求：计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来
public class Test4 {
public static void main(String[] args) {
		
		Test4 test = new Test4();
		int n = 10;
		int value = test.Fib(n);
		System.out.println(value);
	
		for(int i = 1;i <= n;i++){
			System.out.print(Fib(i) + " ");
		}
	}
	
	public  static int Fib(int n ) {
		
		if (n == 1 || n == 2) {
			return 1;
		} else {
			return Fib(n - 1) + Fib(n - 2);
		}
	}

}

汉诺塔

 

package com.atguigu.java2;
import java.util.Scanner;
public class Hanuota {
	static int m = 0;//标记移动次数
	
	//实现移动的函数
	
	public static void move(int disks, char N, char M){
		System.out.println("第" + (++m) + " 次移动 : " + " 把 " + disks + " 号圆盘从 " + N + " ->移到->  " + M);
	}
	
	// 递归实现汉诺塔的函数
	
	public static void hanoi(int n,char A,char B,char C){
		if (n == 1){ //圆盘只有一个时，只需将其从A塔移到C塔
			Hanuota.move(1, A, C);//将编号为1的圆盘从A移动到C
		}else{
			hanoi(n -1,A,C,B);//递归，把A塔上编号1~n-1的圆盘移到B上，以C为辅助器
			Hanuota.move(n, A, C);//把A塔上编号为n的圆盘移到C上
			hanoi(n-1,B,A,C);//递归，把B塔上编号1~n-1的圆盘移到C上，以A为辅助器
		}
		
	}
	
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		
		char A = 'A';
		char B = 'B';
		char C = 'C';
		System.out.println("******************************************************************************************");
        System.out.println("汉诺塔问题（把A塔上编号从小号到大号的圆盘从A塔通过B辅助塔移动到C塔上去---山东科技大学昝道广)");
        System.out.println("******************************************************************************************");
        System.out.print("请输入圆盘的个数：");
        
        int n = in.nextInt();
        Hanuota.hanoi(n, A, B, C);
        System.out.println(">>移动了" + m + "次，把A上的圆盘都移动到了C上");
        in.close();
	}
	
	
	
	
	
}

快排

package com.atguigu.java2;

import java.nio.charset.MalformedInputException;

/*
 * 基本思路：
 * 首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，
 * 然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。
 * 
 * 最优情况如下：
 * 快速排序需要栈空间来实现递归，如果数组按局等方式被分割时，则最大的递归深度为 log n，需要的栈空间为 O(log n)。
 * 比较坏的情况下在递归的每一级上，数组分割成长度为0的左子数组和长度为 n - 1 的右数组。
 * 这种情况下，递归的深度就成为 n，需要的栈空间为 O(n)。
 * 
 * 最坏情况如下：
 * 当基数值不能很好地分割数组，即基准值将数组分成一个子数组中有一个记录，
 * 而另一个子组组有 n -1 个记录时，下一次的子数组只比原来数组小 1，这是快速排序的最差的情况。
 * 如果这种情况发生在每次划分过程中，那么快速排序就退化成了冒泡排序，其时间复杂度为O(n2)。
 *
 * 稳定性如下：
 * 因为快速排序在进行交换时，只是根据比较基数值判断是否交换，且不是相邻元素来交换，
 * 在交换过程中可能改变相同元素的顺序，因此是一种不稳定的排序算法。
 */
public class QuickSort {
	/**
	 * 
	 * @Description 随机数组生成 ，长度为size，取值范围为(-value,value)
	 * @author kanso258
	 * date2021年11月21日上午12:01:47
	 * @param size
	 * @param value
	 * @return 随机排序数组
	 */
	public static int[] randomArray(int size, int value) {
		int[] arr = new int[size];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * (value + 1)) - (int) (Math.random() * value);
		}
		return arr;
	}
	
	public static void main(String[] args) {
		int[] the_array = randomArray(10, 50);
		System.out.print("之前的排序：");
		for (int i = 0; i < the_array.length; i++) {
			System.out.print(the_array[i] + " ");

		}//遍历随机生成的原数组
		System.out.println();
		int[] result_array = quickSort(the_array, 0, the_array.length - 1);
		System.out.print("快速排序：");
		for (int i = 0; i < result_array.length; i++) {
			System.out.print(result_array[i] + " ");
		}//遍历排序后的新数组
	}

	/**
	 * 
	 * @Description 快排方法的实现:我们在数组的第一个位置放个标识m，最后一个位置放一个标识n，
	 * m一直向后移，直到遇到一个比m大的，n一直向左移，直到遇到一个比n小的，然后交换，交换完之后继续循环。
	 * @author kanso258
	 * date2021年11月21日上午12:00:17
	 * @param the_array
	 * @param start
	 * @param end
	 * @return 排序好的数组
	 */
	public static int[] quickSort(int[] the_array, int start, int end) {
		if (start <= end) {
			//
			int m = start, n = end;
			int the_base = the_array[m];
			while (m < n) {
				while ((m < n) && (the_array[n] >= the_base)) {
					n--;
				}
				the_array[m] = the_array[n];
				while ((m < n) && (the_array[m] <= the_base)) {
					m++;
				}
				the_array[n] = the_array[m];
				the_array[m] = the_base;
				quickSort(the_array, start, m - 1);
				quickSort(the_array, n + 1, end);

			}

		}
		return the_array;
	}
}