2024 蓝桥打卡Day35

最新推荐文章于 2024-06-21 17:14:47 发布

屠苏之易，百里之峰

最新推荐文章于 2024-06-21 17:14:47 发布

阅读量1.1k

点赞数 28

文章标签： java 算法

本文链接：https://blog.csdn.net/weixin_53387320/article/details/137470585

版权

本文介绍了在备战蓝桥杯竞赛中，学习的内容包括搜索算法、Java语言基础、数字反转的两种实现方式，以及sort排序、字符串处理（StringBuilder、substring等）、HashSet操作。

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

20240407蓝桥杯备赛

1、学习蓝桥云课省赛冲刺课【3-搜索算法】【4-枚举与尺度法】
2、学习蓝桥云课Java省赛无忧班【1-语言基础】
3、代码练习

1、学习蓝桥云课省赛冲刺课【3-搜索算法】【4-枚举与尺度法】

2、学习蓝桥云课Java省赛无忧班【1-语言基础】

3、代码练习

数字反转

package THL_0407;

import java.util.Scanner;

public class Demo01 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt(); // 读取用户输入的整数

        if (num > 0) { // 如果数字大于0
            StringBuilder string = new StringBuilder(); // 创建一个StringBuilder对象
            string.append(num); // 将数字追加到StringBuilder对象中
            StringBuilder string1 = new StringBuilder();
            string1 = string.reverse(); // 反转StringBuilder对象中的字符串
            String string2 = string1.toString(); // 将反转后的字符串转换为普通字符串
            int num1 = Integer.valueOf(string2); // 将字符串转换为整数
            System.out.println(num1); // 输出反转后的整数
        } else { // 如果数字小于等于0
            num = num * (-1); // 将数字取绝对值
            StringBuilder string = new StringBuilder(); // 创建一个StringBuilder对象
            string.append(num); // 将数字追加到StringBuilder对象中
            StringBuilder string1 = new StringBuilder();
            string1 = string.reverse(); // 反转StringBuilder对象中的字符串
            String string2 = string1.toString(); // 将反转后的字符串转换为普通字符串
            int num1 = Integer.valueOf(string2); // 将字符串转换为整数
            num1 = num1 * (-1); // 将反转后的整数乘以-1，恢复原始数字的负号
            System.out.println(num1); // 输出反转后的整数
        }
    }
}

数字反转优化算法

package THL_0407;

import java.util.Scanner;
import java.lang.Math;

public class Demo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt(); // 读取用户输入的整数

        StringBuilder string = new StringBuilder(); // 创建一个StringBuilder对象
        string.append(Math.abs(num)); // 将数字的绝对值追加到StringBuilder对象中
        StringBuilder reversedString = string.reverse(); // 反转StringBuilder对象中的字符串
        int reversedNum = Integer.parseInt(reversedString.toString()); // 将反转后的字符串转换为整数

        if (num < 0) { // 如果原始数字为负数
            reversedNum *= -1; // 将反转后的数字乘以-1，恢复原始数字的负号
        }

        System.out.println(reversedNum); // 输出反转后的整数
    }
}

sort排序相关

package THL_0407;

import java.util.Arrays;
import java.util.*;
import java.util.List;

import com.sun.jdi.connect.spi.Connection;

public class Demo_sort {

	public static void main(String[] args) {
		List<Integer> list = new ArrayList<>();
		list.add(8);
		list.add(4);
		list.add(5);
		list.add(6);
		list.add(9);
		list.add(3);
		list.add(1);
		Collections.sort(list);
		for (Integer integer : list) {
			System.out.print(integer+" ");
		}
		System.out.println();
		
		Collections.sort(list,new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return o2-o1;
			}
		});
		for (Integer integer : list) {
			System.out.print(integer+" ");
		}
		System.out.println();
		
		Collections.sort(list,(o1,o2)->o2-o1); // 实现降序排序
		System.out.print("实现降序排序：");
		for (Integer integer : list) {
			System.out.print(integer+" ");
		}
		System.out.println();
		
		Collections.sort(list,(o1,o2)->o1-o2); // 实现升序排序
		System.out.print("实现升序排序：");
		for (Integer integer : list) {
			System.out.print(integer+" ");
		}
		System.out.println();
		
		for (Integer integer : list) {
			System.out.print(integer+" ");
		}
		System.out.println();
	
//		Integer[] array = {3,2,5,4,6,9};
//		Arrays.sort(array);
//		// foreach快捷键
//		for (int i : array) {
//			System.out.print(i);
//		}
//		System.out.println();
//		
//		// 实现降序排序
//		Arrays.sort(array, new Comparator<Integer>() {
//
//			public int compare(Integer a, Integer b) {
//				return b - a; //  return b.compareTo(a);
//			}
//		});
//		for (Integer integer : array) {
//			System.out.print(integer);
//		}
//		System.out.println();
//		
//		// 用lambda实现升序排序
//		Arrays.sort(array,(o1,o2)->o1-o2);
//		System.out.print("用lambda实现升序排序:");
//		for (Integer integer : array) {
//			System.out.print(integer);
//		}
//		System.out.println();
//		// 用lambda实现降序排序
//		Arrays.sort(array,(o1,o2)->o2-o1);
//		System.out.print("用lambda实现降序排序:");
//		for (Integer integer : array) {
//			System.out.print(integer);
//		}
//		System.out.println();
//			
//		
//		// 用Arrays.fill(array1, 0)给数组初始化
//		int[] array1 = new int[10];
//		Arrays.fill(array1, 0);
//		for (int i : array1) {
//			System.out.print(i);
//		}
//		System.out.println();
//
	}

}

String字符串相关

package THL_0407;

import java.util.Scanner;

public class Demo_String {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String string0 = "hahaha"; // 定义一个字符串变量并初始化为"hahaha"
        String string = sc.nextLine(); // 从用户输入中读取一行字符串
        System.out.println("string = " + string); // 打印字符串变量的值
        System.out.println("string的第三个字符为 = " + string.charAt(2)); // 使用charAt方法获取字符串中索引为2的字符
        System.out.println("string0和string1作比较：" + (string0.compareTo(string) == 0 ? "相同" : "不同")); // 使用compareTo方法比较两个字符串的大小关系
        String string1 = "fighting"; // 定义一个字符串变量并初始化为"fighting"
        System.out.println("连接字符串string0+string1 = " + string0.concat(string1)); // 使用concat方法连接两个字符串
        String string2 = "hahahafighting"; // 定义一个字符串变量并初始化为"hahahafighting"
        System.out.println("string2与连接的字符串作比较：" + string2.equals(string0.concat(string1))); // 使用equals方法比较两个字符串的内容是否相等
        String string3 = "helloworldhello"; // 定义一个字符串变量并初始化为"helloworldhello"
        System.out.println("world在字符串string3中第一次出现的索引下标为：" + string3.indexOf("world")); // 使用indexOf方法找到子字符串在原字符串中第一次出现的索引
        System.out.println("hahah在字符串string3中第一次出现的索引下标为：" + string3.indexOf("hahaha")); // 如果子字符串不存在，则返回-1
        String string4 = "hello world zoe haha"; // 定义一个字符串变量并初始化为"hello world zoe haha"
        System.out.println("string4的索引区间[12,15)：" + string4.substring(12, 15)); // 使用substring方法提取字符串的子串，左闭右开区间
        String string5 = "helloworld"; // 定义一个字符串变量并初始化为"helloworld"
        char[] ch = string5.toCharArray(); // 将字符串转换为字符数组
        for (int i = 0; i < ch.length; i++) { // 遍历字符数组
            System.out.print(ch[i]); // 打印每个字符
        }
        System.out.println();
        String string6 = ""; // 定义一个空字符串
        System.out.println("string5是否是空字符串：" + string5.isEmpty()); // 判断字符串是否为空，返回布尔值
        System.out.println("string6是否是空字符串：" + string6.isEmpty());

        // String的两种构造方法 + 常用方法
        String str = sc.nextLine(); // 从用户输入中读取一行字符串
        String str1 = sc.next(); // 只能接收到输入第一个空格之前的内容
        System.out.println(str); // 打印字符串
        System.out.println(str1); // 打印字符串

        String[] str2 = str.split(" "); // 使用split方法将字符串按照空格分割成字符串数组
        System.out.println("str2.length = " + str2.length); // 打印字符串数组的长度
        for (int i = 0; i < str2.length; i++) { // 遍历字符串数组
            System.out.print(str2[i] + " "); // 打印每个字符串元素
        }
        System.out.println();

        String[] str3 = str.split(" ", 3); // 使用split方法将字符串按照空格分割成字符串数组，最多分割成3个子串
        System.out.println("str3.length = " + str3.length); // 打印字符串数组的长度
        for (int i = 0; i < str3.length; i++) { // 遍历字符串数组
            System.out.print(str3[i] + " "); // 打印每个字符串元素
        }
        System.out.println();

        sc.close(); // 关闭Scanner对象，释放资源
    }
}

StringBuilder字符串相关

package THL_0407;

import java.util.Scanner;

public class Demo_StringBuilder {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String string = sc.nextLine(); // 从用户输入中读取一行字符串

        StringBuilder str = new StringBuilder(); // 创建一个StringBuilder对象
        str.append(string); // 将输入的字符串追加到StringBuilder对象中
        StringBuilder str1 = new StringBuilder();
        str1 = str.reverse(); // 反转StringBuilder对象中的字符串
        System.out.println("string = " + string); // 打印原始字符串
        System.out.println("string反转后为 = " + str1); // 打印反转后的字符串

        int num = 265512000; // 定义一个整数
        String string1 = num + ""; // 将整数转换为字符串
        StringBuilder str2 = new StringBuilder();
        str2.append(string1); // 将字符串追加到StringBuilder对象中
        str2 = str2.reverse(); // 反转StringBuilder对象中的字符串
        String string2 = str2.toString(); // 将StringBuilder对象转换为字符串
        int num1 = Integer.valueOf(string2); // 将字符串转换为整数
        System.out.println("num反转输出为：" + num1); // 打印反转后的整数

        StringBuilder string3 = new StringBuilder();
        string3.append("zoe,helloworld"); // 将字符串追加到StringBuilder对象中
        System.out.println("hello字符串第一次出现的位置为：" + string3.indexOf("hello")); // 打印子字符串在原字符串中第一次出现的索引位置

        StringBuilder string4 = new StringBuilder();
        string4.append(""); // 将空字符串追加到StringBuilder对象中
        System.out.println("string3是空字符串吗？" + string3.isEmpty()); // 判断StringBuilder对象是否为空字符串，返回布尔值
        System.out.println("string4是空字符串吗？" + string4.isEmpty());

        System.out.println("string3索引为3的字符为：" + string3.charAt(3)); // 获取StringBuilder对象中索引为3的字符

        sc.close(); // 关闭Scanner对象，释放资源
    }
}

HashSet相关

package THL_0407;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

public class Demo_set {

	public static void main(String[] args) {
		Set<Integer> set = new HashSet<>();
		set.add(8);
		set.add(2);
		set.add(8);
		set.add(2);
		set.add(7);
		set.add(2);
		set.add(5);
		set.add(2);
		
		
		for (Integer integer : set) {
			System.out.print(integer+" ");
		}
		System.out.println();
		
		
		ArrayList<Integer> list = new ArrayList<>(set);
		Collections.sort(list);
		System.out.print("升序输出：");
		for (Integer integer : list) {
			System.out.print(integer+" ");
		}
		System.out.println();

		Collections.sort(list,(o1,o2)->o2-o1);
		System.out.print("降序输出：");
		for (Integer integer : list) {
			System.out.print(integer+" ");
		}
		System.out.println();	
	}

}

package THL_0407;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Demo_set02 {

    public static void main(String[] args) {
        // 创建一个包含指定元素的 HashSet
        Set<String> set1 = new HashSet<>();
        set1.add("h");
        set1.add("e");
        set1.add("l");
        set1.add("l");
        set1.add("o");
        
        // 创建一个 Scanner 对象用于接收用户输入
        Scanner sc = new Scanner(System.in);
        // 读取用户输入的字符串
        String str = sc.nextLine();
        
        // 创建一个空的 HashSet
        Set<String> set = new HashSet<>();
        // 将用户输入的字符串拆分为单个字符，并添加到 set 集合中
        for (int i = 0; i < str.length(); i++) {
            set.add(String.valueOf(str.charAt(i)));
        }
        
        // 初始化计数器
        int count = 0;
        // 遍历 set 集合中的每个元素
        for (String string : set) {
            // 如果 set1 集合包含当前元素，则增加计数器
            if(set1.contains(string)) {
                count++;
            }
        }
        // 输出计数器的值，即两个集合的交集元素个数
        System.out.println(count);
                
        // 移除 set1 中的一个元素
        set1.remove("l");
        // 检查 set 是否包含指定元素
        System.out.println(set.contains("l"));
        
        // 使用 retainAll() 方法获取两个集合中相同的元素
        set.retainAll(set1);
        // 输出两个集合的交集元素个数
        System.out.println(set.size());
        
        // 清空 set 集合中的所有元素
        set.clear();
        // 输出清空后 set 集合的大小
        System.out.println(set.size());

        
    }
}