1 函数题 1-8
1），比较
//public class Student implements Comparable<Student>，Comparable<Student> 接口要求
//实现一个 compareTo 方法，允许你定义两个 Student 对象之间的排序规则
@Override
public int compareTo(Student o)
{
if(this.math!=o.math)
return this.math-o.math;//从小到大this在前
else if( this.english!=o.english)
return o.english-this.english;//从大到小o在前
else if(this.cs!=o.cs)
return this.cs-o.cs;
else if(!this.name.equals(o.name))
return o.name.compareTo(this.name);//逆序o在前
else
return this.id-o.id;
}
2),重写类输出
public String toString
//返回String
3），链表和集合
class StringList {
public LinkedList<String> constructList(String[] strs) {
LinkedList<String> ll = new LinkedList<String>();//存储结果
HashSet<Integer> hs = new HashSet<Integer>();//存储长度
for (int i = 0; i < strs.length; i++) {
if (hs.contains(strs[i].length())) {
continue;
} else {
ll.add(strs[i]);
hs.add(strs[i].length());
}
}
return ll;
}
/*
链表LinkedList，集合Hashset，是Integer，因为只能储存对象，不能
直接存储基本数据类型。
Hashset不保证元素顺序，元素不重复。
add，remove，contains，size，clear，iterator
LinkedList保证插入顺序，允许重复动态增减
add,move,get,set(替换),size,clear,iteartor,contains
快捷遍历 for (String x : list)
*/
public String search(LinkedList<String> list) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
String result = "not exist";
for (String x : list) {
if (x.length() == n) {
return x;
}
}
return result;
}
}
4）动态数组
// 将字符串按空格分割，并返回一个可修改的 List
public static List<String> convertStringToList(String line) {
// 使用 ArrayList 来包装 Arrays.asList 的结果
return new ArrayList<>(Arrays.asList(line.split("\\s+")));
/*List<String> s = new ArrayList<String>();
s = Arrays.asList(line.split("\\s+"));
return s;
aslist返回的大小固定不可变，修改会报错
*/
}
// 移除列表中的指定字符串
public static void remove(List<String> list, String str) {
//list.remove(str);
list.removeIf(e -> e.equals(str));
//e -> e.equals(str)，即删除所有等于 str 的元素
//只会删除列表中 第一个匹配的元素
}
/*
ArrayList有顺序允许重复，随机访问
add,get,indexOf,set,remove(指定位置或首次出现的元素）,size,clear,toArray
*/
public static List<String> convertStringToList(String line)
{
List<String> s = new ArrayList<String>();//声明方法
String str = "";
for(int i=0;i<line.length();i++)
{
char c = line.charAt(i);
if(c==' ')
{
if(!str.equals("")) s.add(str);
str="";
}
else {
str+=c;
}
}
if(!str.equals("")) s.add(str); //若str非空，最后的单词加入
return s;
}
public static void remove(List<String> list, String str)
{
List<String> s = new ArrayList<String>();
s.add(str);
list.removeAll(s);
//removeAll需要传入一个集合
}
5)迭代器
class MyTool{
public static void separateStu_T(List persons,List teachers,List students){
Iterator It = persons.iterator();//迭代器
while( It.hasNext()){
Person p= (Person) It.next();
if(p instanceof Teacher){
teachers.add((Teacher)(p));
}
else{// if( It.next() instanceof Student){
students.add((Student)(p));
}
}
}
}
以上为函数体1-8
2 编程题 1-8
1）去除换行符
ArrayList<String> list = new ArrayList<String>();
int n = cin.nextInt();
String s = cin.nextLine();//!!!不去换行符会出错
while(n -- != 0)
{
s = cin.nextLine();
2），重写比较
list.sort(new Comparator<String>() {
//一个用于比较 String 类型的对象的比较器
//创建了一个匿名类，这个匿名类实现了 Comparator<String> 接口。
@Override
//compare 方法是 Comparator 接口中的一个方法
public int compare(String o1, String o2) {
return Integer.parseInt(o1.substring(0, 4)) - Integer.parseInt(o2.substring(0, 4));
//小于0则o1在前，从小到大排序
}
});
3），mapset去重
键对应的值可以更新
Map<String, String> map = new TreeMap<String, String>();
//会打乱顺序，元素顺序不一定与插入顺序一致
LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
//有序的，可以保证元素插入顺序
for(int i = 1; i <= n; i ++)
{
String s = cin.nextLine();
String t = s.substring(0, 4);
map.put(t, s);
//将学号作为key
}
System.out.println(map.size());
for(String it : map.keySet())
{
//返回一个包含所有 Map 中键（key）的 集合（Set）
System.out.println(map.get(it));
}
4），集合判等
Set<Integer> set1=new HashSet<Integer>()
Set<Integer> set2=new HashSet<Integer>();
if(set1.containsAll(set2)&&set2.containsAll(set1)) {
System.out.println("YES");
5),比较去重
!list.contains(girl)
//判断列表中是否已经有该元素
list.sort(new Comparator<Girl>()
{
@Override
public int compare(Girl o1, Girl o2) {
if(o1.hh == o2.hh)
return o2.age - o1.age;
return o1.hh - o2.hh;
}
});
//匿名内部类比较
for(Girl it : list)
System.out.println(it);
//输出
//类里重写比较函数
@Override
public boolean equals(Object obj) {
Girl g = (Girl) obj;
if(hh!=g.hh)
return false;
if(age!=g.age)
return false;
if(!name.equals(g.name))
return false;
if(!phone.equals(g.phone))
return false;
return true;
}
6），计数器
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Map<String, Integer> map = new TreeMap<String, Integer>();
String str;
int[] book = new int[200];//记录每一个字符出现的次数
while (true)
{
str = input.nextLine();
if (str.equals("0000"))//循环结束条件
{
break;
}
str = str.toUpperCase();//题目要求将文本全部转化为大写字母
for (int i = 0; i < str.length(); i++)//记录改行字符串中每一个字符
{
book[str.charAt(i)]++;
}
String[] temp = str.split(" ");//通过split函数将字符串通过其中所含有的空格分开，分开后就成了一个个单词
for (int i =0; i < temp.length; i++)//将每个单词记录进map中
{
if (map.containsKey(temp[i]))//如果map中已经记录过该单词，将该单词对应的值加一
{
map.put(temp[i],map.get(temp[i]) + 1);
}
else//如果没有记录过，创建一个键值对
{
map.put(temp[i], 1);
}
}
}
String text_Max = null, text_Min = null;//记录出现次数最多的单词和出现最少的单词
int Max = 0, Min = 100000000;//记录出现次数最多和最少的次数
for( String it:map.keySet())
{
if(map.get(it)>Max||(map.get(it)==Max&&it.compareTo(text_Max) > 0))
//这里需要调用compareto
{ text_Max=it;
Max=map.get(it);
}
if(map.get(it)<Min)
{ text_Min=it;
Min=map.get(it);
}
}
// }
System.out.printf("%-10s%8d\n", text_Max, Max);
//-代表左对齐，如果少于10个，则用空格补齐
//%8d右对齐字符宽度至少为8
System.out.printf("%-10s%8d\n", text_Min, Min);
for (int i = 'A'; i <= 'Z'; i++)
{
System.out.printf("%-10c%8d\n", i, book[i]);
}
input.close();
}
}
7），迭代器遍历
import java.util.Map.Entry;
Iterator it = map.entrySet().iterator();
//map.entrySet() 返回 Map 中所有的键值对（即 Map.Entry 对象）的集合
while(it.hasNext())
{
Entry ex = (Entry)it.next();
//it.next() 返回迭代器中的下一个元素，在这里是一个 Map.Entry 对象。Map.Entry 对象表示一个键值对
// Entry ex 变量用来保存当前遍历的 Map.Entry 对象。注意，Entry 是 Map.Entry 的一个简写
System.out.println(ex.getKey() + " " + ex.getValue());
}
