1.产生10个1-100的随机数,并放到一个数组中,把数组中大于等于10的数字放到一个list集合中,并打印到控制台。
public static void main(String[] args) {
// 生成随机数
Random r = new Random();
//创建数组
int [] arr = new int[10];
//创建一个List集合
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < arr.length; i++) {
//把随机数存进数组
arr[i] = r.nextInt(100);
//如果值大于10 执行到这加入集合
if (arr[i] > 10){
list.add(arr[i]);
}
}
System.out.println(list);
}
2.已知数组存放一批QQ号码,QQ号码最长为11位,最短为5位String[] strs = {"12345","67891","12347809933","98765432102","67891","12347809933"}。 将该数组里面的所有qq号都存放在LinkedList中,将list中重复元素删除,将list中所有元素分别用迭代器和增强for循环打印出来。
public class SecondClass {
public static void main(String[] args) {
String[] strs = {"12345", "67891", "12347809933", "98765432102", "67891", "12347809933"};
// 创建数组
LinkedList<String> list = new LinkedList<String>();
//将String[]中的QQ号,放到list集合当中
for(String s : strs){
list.add(s);
}
// 去除LinkedList中的重复元素
// 利用HashSet去重
HashSet<String> set = new HashSet<>(list);
// 清空LinkedList
list.clear();
// 将去重后的元素重新放入LinkedList中
list.addAll(set);
//遍历集合的两个方法:
// 使用迭代器打印LinkedList中的元素
System.out.println("使用迭代器打印LinkedList中的元素:");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
// 使用增强for循环打印LinkedList中的元素
System.out.println("使用增强for循环打印LinkedList中的元素:");
for (String s : list) {
System.out.println(s);
}
}
}
3. 分别用Comparable和Comparator两个接口对下列四位同学的成绩做降序排序,如果成绩一样, 那在成绩排序的基础上按照年龄由小到大排序。
姓名(String) | 年龄(int) | 分数(float) |
刘桑 | 20 | 90.0F |
李斯 | 22 | 90.0F |
王武 | 20 | 99.0F |
孙俪 | 22 | 100.0F |
编写一个Student类用来实现Comparable<Student>接口,并在其中重写CompareTo(Student o)方法 在主函数中使用Comparable 与 Comparetor分别对ArrayList进行排序.
public class Student implements Comparable<Student> {
//public class Student{
//姓名
private String name;
//年龄
private int age;
//分数
private float score;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
public Student(String name, int age, float score) {
this.name = name;
this.age = age;
this.score = score;
}
// 实现 compareTo 方法,按照成绩降序,成绩相同时按照年龄升序
public int compareTo(Student o) {
// 首先按照成绩降序排序
if (this.score != o.score) {
return Float.compare(o.score, this.score); // 降序排序
} else {
// 如果成绩相同,按照年龄升序排序
return Integer.compare(this.age, o.age);
}
}
// toString 方法,方便输出
@Override
public String toString() {
return
"name='" + name + '\'' +
", age=" + age +
", score=" + score;
}
}
//public class Main implements Comparator<Student> {
public class Main {
public static void main(String[] args) {
// 创建学生列表
ArrayList<Student> S = new ArrayList<>();
S.add(new Student("刘桑", 20, 90.0F));
S.add(new Student("李斯", 22, 90.0F));
S.add(new Student("王武", 20, 99.0F));
S.add(new Student("孙俪", 22, 100.0F));
//使用 Comparable 接口排序(按照成绩降序,成绩相同时按照年龄升序)
Collections.sort(S);
for (int i = 0; i < S.size(); i++) {
Student student = S.get(i);
System.out.println(student);
}
// 使用Comparator进行降序排序,成绩相同按年龄升序
// Comparator<Student> scoreComparator = new Comparator<Student>() {
// @Override
// public int compare(Student s1, Student s2) {
// // 比较分数,降序
// if (Float.compare(s2.getScore(), s1.getScore()) != 0) {
// return Float.compare(s2.getScore(), s1.getScore());
// }
// // 如果分数相同,按年龄升序
// return Integer.compare(s1.getAge(), s2.getAge());
// }
// };
//
// // 使用Comparator进行排序
// Collections.sort(S, scoreComparator);
//
// // 打印排序后的学生信息
// for (Student student : S) {
// System.out.println(student);
// }
// }
}
}
要注意上诉是两个方法:Comparable 和Comparetor
4. "fdgavcbsacdfs" 获取该字符串中,每一个字母出现的次数。
要求打印结果是:a(2)b(1)...;
public class FourthlyClass {
public static void main(String[] args) {
String str = "fdgavcbsacdfs";
// 定义Map
Map<Character, Integer> charCountMap = new TreeMap<Character, Integer>();
// 遍历字符串,统计每个字母出现的次数
for (char c : str.toCharArray()) {
if (charCountMap.containsKey(c)) {
charCountMap.put(c, charCountMap.get(c) + 1);
} else {
charCountMap.put(c, 1);
}
}
// 格式化输出结果
StringBuilder result = new StringBuilder();
for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {
result.append(entry.getKey()).append("(").append(entry.getValue()).append(")");
}
System.out.println(result.toString());
}
}
5. 选择某种Map集合保存学号从1到15的学员的学号(键)和姓名(值),学号用字符串表示,输入的时候要以学号乱序的方式存入Map集合,然后按照学号从大到小的顺序将Map集合中的元素输出打印。需要自定义Map集合的比较器Comparator,因字符串对象的大小比较是按字典序,而非对应的数值。 要求:必须使用Map集合的内部排序机制进行排序,不能在外部排序。
public class Students {
public static void main(String[] args) {
HashMap<String,String> studentsMap = new HashMap<String,String>();
studentsMap.put("8","love");
studentsMap.put("10","wiggins");
studentsMap.put("1","Anthony");
studentsMap.put("11","Book");
studentsMap.put("2","Curry");
studentsMap.put("12","Davis");
studentsMap.put("3","EdWards");
studentsMap.put("13","Francis");
studentsMap.put("4","Giannis");
studentsMap.put("14","Harden");
studentsMap.put("5","James");
studentsMap.put("15","Kobe");
studentsMap.put("6","Malone");
studentsMap.put("7","Nash");
studentsMap.put("9","LeBron");
// 创建Comparator按照学号从大到小排序
Comparator<String> comparator = (o1, o2) -> {
Integer s1 = Integer.parseInt(o1);
Integer s2 = Integer.parseInt(o2);
return s2.compareTo(s1); // 从大到小排序
};
// 将HashMap的entrySet转换为List进行排序
List<Map.Entry<String, String>> entryList = new ArrayList<>(studentsMap.entrySet());
// 使用Comparator进行排序
entryList.sort(Map.Entry.comparingByKey(comparator));
// 打印排序后的结果
System.out.println("按照学号从大到小的顺序输出:");
for (Map.Entry<String, String> entry : entryList) {
System.out.println("学号:" + entry.getKey() + ", 姓名:" + entry.getValue());
}
}
}
6. 编写一个Book类,该类至少有name和price两个属性。该类要实现Comarable接口,在接口的compareTo()方法中规定两个Book类实例的大小关系为二者的price属性的大小关系。在主函数中,选择合适的集合类型存放Book类的若干个对象,然后创建一个新的Book类的对象,并检查该对象与集合中的哪些对象相等。查询结果如下:
新书:《模式识别》与下列图书:
Java基础教程
数据库技术
C++基础教程
价格相同,具体价格为:29.0元。
public class Book implements Comparable<Book> {
private String name;
private double price;
public Book(String name, double price) {
this.name = name;
this.price = price;
}
//get 和 set
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
// 实现 compareTo方法,按价格比较
@Override
public int compareTo(Book o) {
if (this.price < o.price) {
return -1;
} else if (this.price > o.price) {
return 1;
} else {
return 0;
}
}
// 重写 toString 方法
@Override
public String toString() {
return name + ": " + price + "元";
}
}
public class Test {
public static void main(String[] args) {
// 创建一个 ArrayList 存放 Book 对象
ArrayList<Book> books = new ArrayList<>();
// 添加一些 Book 对象
books.add(new Book("\t\t\tJava基础教程", 29.0));
books.add(new Book("\t\t\t数据库技术", 29.0));
books.add(new Book("\t\t\tC++基础教程", 29.0));
books.add(new Book("\t\t\tPython编程",35.0));
books.add(new Book("\t\t\tC程序设计",25.5));
// 创建一个新的 Book 对象
Book newBook = new Book("《模式识别》",29.0);
// 输出新书与集合中的每本书比较的结果
System.out.println("新书:" + newBook.getName() + " 与下列图书:");
for (Book book : books) {
if (newBook.compareTo(book) == 0) {
System.out.println("\t" + book.getName());
}
}
System.out.println("价格相同,具体价格为:" + newBook.getPrice() + "元。");
}
}
7. 按照要求定义一个操作类:要求完成一个一维数组操作类,其中可以加入任意类型的数据,数组的具体操作类型由程序外部决定,并且可以实现查询的功能
public class Operations<T> {
private T[] array;
//get和set
public T[] getArray() {
return array;
}
public void setArray(T[] array) {
this.array = array;
}
//构造方法,初始化数组
public Operations(T[] array) {
this.array = array;
}
}