Java基础编程500题——阶段练习1

已于 2024-07-23 22:49:34 修改
阅读量1.1k 收藏 14
点赞数 24
分类专栏： Java基础编程500题 文章标签： java 开发语言 数据结构 算法 spring
于 2024-07-21 12:37:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53140426/article/details/140580670
版权

💥 该系列属于【Java基础编程500题】专栏，如您需查看Java基础的其他相关题目，请您点击左边的连接

目录

1. 【方法，数组】编写一个方法，该方法接收一个整数数组，使用循环找到数组中的最大值和最小值，并计算它们的平均值。

2. 【String，Map】输入一个字符串，输出该字符串中每个字符出现的次数，并按照字符的ASCII码值从小到大排序输出。

3. 【泛型，集合，Collections】定义一个泛型方法，将两个List合并为一个List，并去除重复元素。然后使用该方法和Collections工具类对合并后的List进行降序排序。

4. 【面向对象，匿名内部类，lambda表达式】定义一个接口Compute，包含一个方法int compute(int a, int b)。使用匿名内部类和lambda表达式分别实现加法、减法、乘法和除法。

5. 【Math，Stream】生成一个长度为10000的[1,100]的随机整数数组，找出数组中的最大值和最小值，并计算它们的平均值。

6. 【String，StringBuilder，Stream，lambda表达式】将用户输入的字符串反转，并且将每个单词的首字母大写。

7. 【泛型，集合，Collections】编写一个泛型方法addElement，该方法接受一个List和一个元素，返回一个包含原始List和给定元素的新List。

8. 【集合，Collections，Stream，lambda表达式】将一个整数列表中{1,2,3,4,...,12}的每个元素乘以2，然后过滤出大于10的元素，并筛选出最大的3个值，最后将结果收集到一个新的列表中。

9. 【String，集合，Stream，lambda表达式】输入一个字符串，输出该字符串中每个单词出现的次数，并按照单词出现的次数降序排序输出。

10. 【面向对象，匿名内部类】定义一个接口Shape，包含一个方法double getArea()。实现几个具体的形状类（如Circle、Rectangle），并使用lambda表达式创建一个匿名类来表示另一个形状。

11. 【String，StringBuilder，Arrays】输入一个字符串，使用StringBuilder将字符串中的所有数字字符提取出来，并转换成整数数组，然后对这个数组进行降序排序并输出。

12. 【泛型，集合】定义一个泛型方法，接收两个Set集合，返回它们的交集。然后使用PriorityQueue将交集元素按自然顺序降序输出（请不要用TreeSet）。

13. 【泛型，集合】定义一个泛型类Pair，它包含两个泛型类型的字段。使用Pair类创建一个List，并添加几个Pair实例。,>

14. 【数组，Math，StringBuilder】编写一个程序，实现以下功能。

15. 【Character，String，StringBuilder】编写一个程序，实现以下功能。

16. 【泛型，匿名内部类，lambda表达式】编写一个程序，实现以下功能。

 ✨✨  返回题目目录 ✨ ✨ 

Java基础编程500题

1. 【方法，数组】编写一个方法，该方法接收一个整数数组，使用循环找到数组中的最大值和最小值，并计算它们的平均值。

public class Main {
    public static void main(String[] args) {
        int[] numbers = {3, 5, 1, 8, 2, 9, 4};
        double[] results = findMinMaxAverage(numbers);
        System.out.println("最大值: " + results[0]);
        System.out.println("最小值: " + results[1]);
        System.out.println("平均值: " + results[2]);
    }

    public static double[] findMinMaxAverage(int[] array) {
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        double sum = 0;

        for (int num : array) {
            if (num > max) max = num;
            if (num < min) min = num;
            sum += num;
        }

        return new double[]{max, min, sum / array.length};
    }
}

2. 【String，Map】输入一个字符串，输出该字符串中每个字符出现的次数，并按照字符的ASCII码值从小到大排序输出。

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.stream.Collectors;

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

        // 方法一
        Map<Character, Long> collect = str.chars()
                .mapToObj(c -> (char) c)
                .collect(Collectors.groupingBy(c -> c, Collectors.counting()));
        TreeMap<Character, Long> map = new TreeMap<>(collect);
        System.out.println(map);

        // 方法二
        Map<Character, Long> charCountMap = new TreeMap<>();
        for (char c : str.toCharArray()) {
            charCountMap.put(c, charCountMap.getOrDefault(c, 0L) + 1);
        }
        System.out.println(charCountMap);

    }
}

3. 【泛型，集合，Collections】定义一个泛型方法，将两个List合并为一个List，并去除重复元素。然后使用该方法和Collections工具类对合并后的List进行降序排序。

import java.util.*;

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

        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> list2 = new ArrayList<>(5);
        Collections.addAll(list2, 1, 3, 5, 7, 9);

        List<Integer> mergeList = merge(list1, list2);
        Collections.sort(mergeList, Collections.reverseOrder());
        System.out.println(mergeList);

    }

    public static <T> List<T> merge(List<T> list1, List<T> list2) {
        Set<T> set = new HashSet<>(list1);
        set.addAll(list2);
        return new ArrayList<>(set);
    }
    
}

4. 【面向对象，匿名内部类，lambda表达式】定义一个接口Compute，包含一个方法int compute(int a, int b)。使用匿名内部类和lambda表达式分别实现加法、减法、乘法和除法。

interface Compute {
    int compute(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        Compute add = new Compute() {
            @Override
            public int compute(int a, int b) {
                return a + b;
            }
        };
        Compute subtract = (a, b) -> a - b;
        Compute multiply = (a, b) -> a * b;
        Compute divide = (a, b) -> (b != 0 ? a / b : 0);

        System.out.println("加法结果: " + add.compute(10, 5));
        System.out.println("减法结果: " + subtract.compute(10, 5));
        System.out.println("乘法结果: " + multiply.compute(10, 5));
        System.out.println("除法结果: " + divide.compute(10, 5));
    }
}

5. 【Math，Stream】生成一个长度为10000的[1,100]的随机整数数组，找出数组中的最大值和最小值，并计算它们的平均值。

import java.util.Arrays;
import java.util.OptionalDouble;

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[10000];
        for (int i = 0; i < 10000; i++) {
            arr[i]= (int) (Math.random() * 100) + 1;
        }
        OptionalDouble average = Arrays.stream(arr).average();
        average.ifPresent(System.out::println);
    }
}

6. 【String，StringBuilder，Stream，lambda表达式】将用户输入的字符串反转，并且将每个单词的首字母大写。

import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);
        String string = sc.nextLine();
        
        StringBuilder sb =new StringBuilder(string);
        String reversedString = sb.reverse().toString();
        
        String[] s = reversedString.split(" ");
        String collect = Arrays.stream(s)
                .map(str -> Character.toUpperCase(str.charAt(0)) + str.substring(1))
                .collect(Collectors.joining(" "));
        
        System.out.println(collect);
        
    }
}

7. 【泛型，集合，Collections】编写一个泛型方法addElement，该方法接受一个List和一个元素，返回一个包含原始List和给定元素的新List。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5, 6);
        Integer element = 7;
        List<Integer> newList = addElement(list, element);
        System.out.println(newList);
    }

    public static <T> List<T> addElement(List<T> list, T element) {
        List<T> newList = new ArrayList<>(list);
        newList.add(element);
        return newList;
    }
}

8. 【集合，Collections，Stream，lambda表达式】将一个整数列表中{1,2,3,4,...,12}的每个元素乘以2，然后过滤出大于10的元素，并筛选出最大的3个值，最后将结果收集到一个新的列表中。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
        List<Integer> newList = list.stream()
                .map(n -> n * 2)
                .filter(n -> n > 10)
                .sorted(Collections.reverseOrder())
                .limit(3)
                .collect(Collectors.toList());
        System.out.println(newList);
    }
}

9. 【String，集合，Stream，lambda表达式】输入一个字符串，输出该字符串中每个单词出现的次数，并按照单词出现的次数降序排序输出。

import java.util.*;
import java.util.stream.Collectors;

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

        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        // String s = "this is a test string for a test program this is a test";
        String[] strs = s.split(" ");

        // 方法一：
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < strs.length; i++) {
            map.put(strs[i], map.getOrDefault(strs[i], 0) + 1);
        }

        ArrayList<Map.Entry<String, Integer>> entries = new ArrayList<>(map.entrySet());
        entries.sort((o1, o2) -> o2.getValue() - o1.getValue()); //点击new即可让idea自动生成

        System.out.println("单词出现次数（降序）:");
        entries.forEach(a -> System.out.println(a.getKey() + " : " + a.getValue()));


        // 方法二：
        System.out.println("单词出现次数（降序）:");
        Arrays.stream(strs)
                .collect(Collectors.groupingBy(a -> a, Collectors.counting()))
                .entrySet()
                .stream()
                .collect(Collectors.toList())
                .stream()
                .sorted((o1, o2) -> o2.getValue().intValue() - o1.getValue().intValue())
                .forEach(entry -> System.out.println(entry.getKey() + " : " + entry.getValue()));


    }
}

10. 【面向对象，匿名内部类】定义一个接口Shape，包含一个方法double getArea()。实现几个具体的形状类（如Circle、Rectangle），并使用lambda表达式创建一个匿名类来表示另一个形状。

interface Shape {
    double getArea();
}

class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 3);
        Shape square = new Shape() {
            @Override
            public double getArea() {
                return 6 * 6;
            }
        };

        System.out.println("Circle area: " + circle.getArea());
        System.out.println("Rectangle area: " + rectangle.getArea());
        System.out.println("Square area: " + square.getArea());
    }
}

11. 【String，StringBuilder，Arrays】输入一个字符串，使用StringBuilder将字符串中的所有数字字符提取出来，并转换成整数数组，然后对这个数组进行降序排序并输出。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Scanner sc= new Scanner(System.in);
        // String test = sc.nextLine();
        String test = "a1b2c3d4e5";

        StringBuilder sb = new StringBuilder();
        for (char i : test.toCharArray()) {
            if (Character.isDigit(i)) {
                sb.append(i);
            }
        }

        String string = sb.toString();
        Integer[] num = new Integer[string.length()];
        for (int i = 0; i < string.length(); i++) {
            char c = string.charAt(i);
            num[i] = c - '0';
        }

        Arrays.sort(num, (o1, o2) -> o2 - o1);
        System.out.println(Arrays.toString(num));

    }
}

12. 【泛型，集合】定义一个泛型方法，接收两个Set集合，返回它们的交集。然后使用PriorityQueue将交集元素按自然顺序降序输出（请不要用TreeSet）。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Set<Integer> set1 = Set.of(1, 2, 3, 4, 5, 6, 8);
        Set<Integer> set2 = Set.of(1, 4, 5, 6, 7, 8, 10);
        Set<Integer> set3 = intersection(set1, set2);

        PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2) -> o2 - o1);
        queue.addAll(set3);

        System.out.println(queue); // 并不是以排序的顺序打印出来，数据结构是最小或最大堆

        while (!queue.isEmpty()) {
            System.out.print(queue.poll() + " ");
        }

    }

    public static <T> Set<T> intersection(Set<T> set1, Set<T> set2) {
        Set<T> set = new HashSet<>(set1);
        set.retainAll(set2);
        return set;
    }

}

13. 【泛型，集合】定义一个泛型类Pair<T, K>，它包含两个泛型类型的字段。使用Pair类创建一个List<Pair>，并添加几个Pair实例。

import java.util.List;

class Pair<T, K> {
    private T first;
    private K second;

    public Pair(T first, K second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public K getSecond() {
        return second;
    }

}

public class Main {
    public static void main(String[] args) {
        Pair<String, Integer> p1 = new Pair<>("你好", 1);
        Pair<String, Integer> p2 = new Pair<>("世界", 2);
        Pair<String, Integer> p3 = new Pair<>("Java", 3);
        List<Pair<String, Integer>> pairs = List.of(p1, p2, p3);
        for (Pair<String, Integer> pair : pairs) {
            System.out.println(pair.getFirst() + " - " + pair.getSecond());
        }
    }
}

14. 【数组，Math，StringBuilder】编写一个程序，实现以下功能。

  1. 创建一个整型数组，包含100个随机整数（范围10-50）。
  2. 使用循环计算数组中所有偶数的和。
  3. 使用StringBuilder将数组中的奇数转换为字符串，并用逗号分隔。
  4. 输出偶数和与奇数字符串。
public class Main {
    public static void main(String[] args) {
        int[] arr = new int[100];
        int sum = 0;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = 10 + (int) (Math.random() * 41);
            if (arr[i] % 2 == 0) {
                sum += arr[i];
            } else {
                sb.append(arr[i]).append(",");
            }
        }
        System.out.println(sum);
        System.out.println(sb);


    }
}

15. 【Character，String，StringBuilder】编写一个程序，实现以下功能。

  1. 输入一个字符串。
  2. 将字符串中的所有小写字母转换为大写。
  3. 计算字符串中元音字母(‘a’, ‘e’, ‘i’, ‘o’, ‘u’)的个数。
  4. 输出转换后的字符串和元音字母个数。
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        // String input = "Hello World";
        StringBuilder sb = new StringBuilder();
        int vowelCount = 0;
        for (char c : input.toCharArray()) {
            if ("aeiouAEIOU".indexOf(c) != -1) {
                vowelCount++;
            }
            sb.append(Character.toUpperCase(c));
        }
        System.out.println("转换后的字符串：" + sb.toString());
        System.out.println("元音字母个数：" + vowelCount);
    }
}

16. 【泛型，匿名内部类，lambda表达式】编写一个程序，实现以下功能。

  1. 定义一个自定义泛型接口MyInterface<T>，包含一个方法print(T t)。
  2. 创建一个类MyClass，实现MyInterface<String>。
  3. 在Main方法中使用匿名内部类实现MyInterface<Integer>，并调用print方法。
  4. 使用lambda表达式实现MyInterface<Double>，并调用print方法。

interface MyInterface<T> {
    void print(T t);
}

class MyClass implements MyInterface<String> {

    @Override
    public void print(String s) {
        System.out.println(s);
    }
}


public class Main {
    public static void main(String[] args) {
        MyInterface<String> strPrint = new MyClass(); //<String>可写可不写，但最好是写上
        strPrint.print("你好");

        MyInterface<Integer> intPrint = new MyInterface<Integer>() {
            @Override
            public void print(Integer o) {
                System.out.println(o);
            }
        };
        intPrint.print(123);

        MyInterface<Double> doublePrint = System.out::println;
        doublePrint.print(123.456);

    }
}

安晴晚风
关注
专栏目录
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7528
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
Java基础综合练习
qq_45466959的博客
11-29 480
Java基础综合练习
Java基础编程500题——综合练习
最新发布
安晴晚风的博客
07-24 1917
Java基础编程500题——综合练习
java练习_Java练习
weixin_32340083的博客
02-19 263
package exec;/*2.根据圆柱体的半径和高，使用下面的公式，计算圆柱的体积面积=半径*半径*π体积=面积*高 */public class work01 {public static void main(String[] args) {// TODO Auto-generated method stub//定义圆柱的高和半径，面积，体积double r,h,s,v;r=3.4;h=8....
Java基础编程题
m0_73952455的博客
05-02 1032
（2） add(Money money)方法，参数为Money类对象，返回值为Money类对象，其中的总金额为当前对象的总金额加上参数money中的总金额。编写MyMath类，实现静态的4个重载方法f(),分别计算不同的函数值，使给定的Test类能正常运行，并实现指定的输出内容。（1） times(int n)方法，参数为int，返回值为Money类对象，其中的总金额为当前对象的总金额乘以参数n。已知公式如下图，编程求f(x,y,z)的值 ，在Test类中实现x，ｙ，ｚ值 的输入及结果的输出。
Java基本练习题（Java编程基础知识）
01-09
这些资料可以帮助初学者掌握基本的算法和编程，对巩固练习很有帮助，里面有很多初学者要掌握的基本的编程知识，这对于以后的编程和应付Java考试时很有帮助滴。
java编程基础 | 练习题
weixin_45780538的博客
08-22 891
此文为本人学习java基础所练习的题型，皆为学习Java路上的必做，适合小白入门练习 文将陆续更新.直到学习到下一进程（2021/8/22) 目录 0.前文概要 1.简单逻辑结构题 2.含有数组题型 0.前文说明 文中所有代码都省略“头文件” 做题中总结的一些小方法： int x=i/100; //求百位 int y=i%100/10; //求十位 int z=i%10; //求个位 1.简单逻辑结构题 1...
Java自学之路——超仔细含练习项目及源码 Java知识体系最强总结————含各个阶段的面试题
08-06
### Java自学之路——超详细含练习项目及源码 #### Java知识体系最强总结 本篇文章旨在根据提供的文件信息，深入解读Java自学之路的关键知识点，并针对其中提到的学习资源进行详细的解析，帮助初学者更好地掌握...
JAVA编程题全集（100题及答案）——直接打印
09-30
1. JAVA 基础知识：资源中提到了 JAVA 程序设计总复习题，包括了基础的 JAVA 程序设计知识，如使用 `System.out.print` 输出字符串、使用 `if-else` 语句判断条件等。 2. JAVA 语句和结构：资源中提供了多种 JAVA ...
Java基础编程题(含答案)
04-29
Java基础编程题(含答案) 一些java基础的编程题 面试题
JAVA编程基础50题
03-17
学习JAVA编程的基础练习题，自做。待更。题目取自其他博主及度娘。
JAVA基础编程练习题50题及经典算法90题【含源码及答案】
07-19
JAVA基础编程练习题50题及经典算法90题【含源码及答案】
JAVA基础编程练习题50题及经典算法90题【含源码及答案】-史上最全
11-24
JAVA基础编程练习题50题及经典算法90题【含源码及答案】-史上最全
50道JAVA基础编程练习题全面解答
11-24
### 知识点总结 #### 1. 斐波那契数列与兔子繁殖问题 - **背景**：本题目探讨了一个经典的数学问题...这些题目不仅涉及基本的Java编程技巧，还涵盖了数学概念的应用，有助于提高学习者的逻辑思维能力和编程实践能力。
java关于多态的题_Java基础之：OOP——多态练习题
weixin_34849898的博客
02-25 880
Java基础之：OOP——多态练习题应用案例1：编写教师类要求有属性“姓名name”，“年龄age”，“职称post”，“基本工资salary”编写业务方法， introduce()，实现输出一个教师的信息。编写教师类的三个子类：教授类(professor)、副教授类(vice professor)、讲师类(lecturer)。工资级别分别为：教授为1.3、副教授为1.2、讲师类1.1。在三个子类...
java基础：12.8 综合练习
weixin_33985679的博客
03-27 211
1、复制文件是常见的IO操作，设计如下方法，实现复制源文件srcFile到目标文件destFile public static void copyFile(String srcFile, String destFile){ } /** * 复制文件 * @param srcFile 原文件/地址 * @param destFile ...
java 基础编程题汇总
Wuguan_7的博客
06-28 739
读入一个表示年份的整数，判断这一年是否是闰年。如何判断一个年份是否是闰年： 1)如果这个年份能够被4 整除，且不能被100 整除，则这一年是闰年。例如， 1996 年是闰年，而相应的， 1993 年就不是闰年。 2)如果这个年份能够被100 整除，则这个数必须要能被400 整除，才是闰年。例如， 2000 年是闰年， 1900 年不是闰年 import java.util.Scanner; public class test { public static void main(String[] a
JAVA编程：详解50道基础编程题之斐波那契兔子问题
"50道JAVA基础编程练习题全面解答" 在Java编程学习中，通过解决基础练习题是提升技能的有效方式。本资源提供的是50道关于JAVA基础编程的练习题及其解答，主要目的是帮助初学者巩固基础知识并提高编程能力。下面我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值