一.生成10个1到20之间的不重复的随机数
分析过程：
1. 需要生成随机数，那么需要Random类
2. 需要存储10个不能重复的数，需要HashSet集合（当前TreeSet还没学习到）
3. 判断，当HashSet的Size小于10就往里存储随机数，等于就停止添加存储元素
4. 通过Random的nextInt()方法获取随机数并加入到HashSet里
5. 遍历HashSet,打印出10个随机数
package hashset;
import java.util.HashSet;
import java.util.Random;
public class Test1_HashSet {
public static void main(String[] args) {
//1.创建Random对象
Random r = new Random();
//2.创建HashSet对象
HashSet<Integer> hs = new HashSet<>(); //注意是包装类不是int
//3.判断并添加元素
while(hs.size()< 10) {
//4.通过Random中随机方法nextInt()获取1到20范围内随机数
hs.add(r.nextInt(20) + 1); //如果不加1，随机范围是0到19
}
//5.遍历HashSet
for (Integer integer : hs) {
System.out.println(integer);
}
}
}从键盘获取一行输入字符串，要求去除重复字符。
分析过程：
1. 需要使用Scanner类
2. 输入的是一行字符串，需要转换成字符数组
3. 创建HashSet集合对象（利用HashSet无法储存相同元素的特性达到去除重复字符的目的）
4. 字符数组遍历元素，并添加进入HashSet集合
5. 变量集合元素
package hashset;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import javax.swing.plaf.synth.SynthSpinnerUI;
public class Test2_HashSet {
public static void main(String[] args) {
//1.创建键盘输入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一行字符串：");
String line = sc.nextLine();
//2.字符串转换成字符数组
char[] c = line.toCharArray();
//3.字符数组转换成集合对象,创建HashSet
HashSet<Character> hs = new HashSet<>();
//4.遍历数组，元素依次添加进集合
for (int i = 0; i < c.length; i++) {
hs.add(c[i]);
}
//5.遍历HashSet集合
for (Character character : hs) {
System.out.println(character);
}
}
}假设顺序列表ArrayList中存储的元素是整型数字1~5，遍历每个元素，将每个元素顺序输出。（list集合遍历方法总结）
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
//假设顺序列表ArrayList中存储的元素是整型数字1~5，遍历每个元素，将每个元素顺序输出。 [必做题]
public class MyArray {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
Iterator<Integer> it = list.iterator();
// 迭代器遍历
while(it.hasNext()){
System.out.println(it.next());
}
// for循环遍历
for(int i = 0;i<list.size();i++){
System.out.println(list.get(i));
}
// 增强for循环
for(Integer i :list){
System.out.println(i);
}
}
}
3、在一个列表中存储以下元素：apple,grape,banana,pear
• 3.1 返回集合中的最大的和最小的元素
• 3.2 将集合进行排序，并将排序后的结果打印在控制台上
import java.util.ArrayList;
import java.util.List;
//3、在一个列表中存储以下元素：
//apple,grape,banana,pear
//• 3.1 返回集合中的最大的和最小的元素
//• 3.2 将集合进行排序，并将排序后的结果打印在控制台上 [必做题
public class MyScort {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("apple");
list.add("grape");
list.add("banana");
list.add("pear");
for(int j = 0;j<list.size()-1;j++){//冒泡排序
for(int i = 0;i<list.size()-1-j;i++){
if(list.get(i).compareTo(list.get(i+1))>0){
String temp = list.get(i);
list.set(i, list.get(i+1));
list.set(i+1, temp);
}
}
}
System.out.print("排序后的顺序：");
for(int i = 0;i<list.size();i++){
System.out.print(list.get(i)+" ");
}
System.out.println();
System.out.println("集合中最大的元素是"+list.get(0));
System.out.println("集合中最小的元素是"+list.get(3));
}
}
编写程序，获取命令行参数中的字符串列表，输出其中重复的字符、不重复的字符以及消除重复以后的字符列表。
public static void main(String[] args) {
String str = "abcdeafblmbnopawc";
System.out.println("原字符串："+str);
Set<Character> set1 = new HashSet<Character>();//消除重复后的字符
Set<Character> set2 = new HashSet<Character>();//重复的字符
Set<Character> set3 = new HashSet<Character>();//不重复的字符
//把字符串转为字符数组
char[] cs = str.toCharArray();
for (char c : cs) {
boolean b = set1.add(c);
if(!b){
set2.add(c);
}
}
//把消除重复后的字符赋给set3
set3.addAll(set1);
//把消除重复后的字符 - 重复的字符 = 不重复的字符
set3.removeAll(set2);
System.out.println("====消除重复后的字符========");
for (char c : set1) {
System.out.print(c+" ");
}
System.out.println("\n====重复的字符========");
for (char c : set2) {
System.out.print(c+" ");
}
System.out.println("\n====不重复的字符========");
for (char c : set3) {
System.out.print(c+" ");
}
}
使用Scanner从控制台读取一个字符串，统计字符串中每个字符出现的次数，要求使用学习过的知识完成以上要求
实现思路根据Set、List、Map集合的特性完成。
public static void main(String[] args) {
String str = "abcdeblmbac";
System.out.println("原字符串："+str);
Map<Character,Integer> map = new HashMap<Character,Integer>();
char[] cs = str.toCharArray();
for (char c : cs) {
if(map.containsKey(c)){
Integer value = map.get(c);
value++;
map.put(c, value);
}else{
map.put(c, 1);
}
}
//遍历map
Set<Character> set = map.keySet();
for (Character c : set) {
System.out.println(c+"出现了"+map.get(c)+"次");
}
}
// 写一个Student类, 包含属性id[1-30), grade[1-6], score[0-100], 所有属性都是随机生成
// 创建一个Set集合, 保存20个对象, 如果两个对象的id是一样的,则不允许添加.
// 使用迭代器遍历集合,打印输出对象的信息, 并找出分数最高的同学和分数最低的同学, 最后打印输出最高分和最低分同学信息.
package Test;
import java.util.*;
// 写一个Student类, 包含属性id[1-30), grade[1-6], score[0-100], 所有属性都是随机生成
// 创建一个Set集合, 保存20个对象, 如果两个对象的id是一样的,则不允许添加.
// 使用迭代器遍历集合,打印输出对象的信息, 并找出分数最高的同学和分数最低的同学, 最后打印输出最高分和最低分同学信息.
public class Test13 {
public static void main(String[] args) {
Set<Student> set = new HashSet<Student>();
for (; set.size() != 20;) {
int id = (int) (Math.random() * 29 + 1);
int grade = (int) (Math.random() * 6 + 1);
double score = (int) (Math.random() * 1001) / 10.0;
set.add(new Student(id, grade, score));
}
for (Student student : set) {
System.out.println(student);
}
System.out.println("---------------------------");
Student maxScoreStudent = null;
Student minScoreStudent = null;
Iterator<Student> iterator = set.iterator();
while (iterator.hasNext()) {
Student student = iterator.next();
if (maxScoreStudent == null) {
maxScoreStudent = student;
minScoreStudent = student;
}
if (student.getScore() > maxScoreStudent.getScore()) {
maxScoreStudent = student;
}
if (student.getScore() < minScoreStudent.getScore()) {
minScoreStudent = student;
}
}
System.out.println(maxScoreStudent);
System.out.println(minScoreStudent);
}
}
class Student implements Comparable<Student> {
private int id;
private int grade;
private double score;
public Student() {
}
public Student(int id, int grade, double score) {
super();
this.id = id;
this.grade = grade;
this.score = score;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student [id=" + id + ", grade=" + grade + ", score=" + score + "]";
}
public int compareTo(Student o) {
return (int) (this.score - o.score);
}
}